Fix Windows x86_64 CI: align CONTEXT to 16 bytes for GetThreadContext/SetThreadContext

Root cause: The windows-sys crate defines CONTEXT with #[repr(C)] which
only provides 8-byte natural alignment on x86_64. However, the Windows
API documentation states: "The CONTEXT structure must be 16-byte aligned
when used with GetThreadContext and SetThreadContext functions."

This explains why ALL i686 Windows targets passed (i686 CONTEXT has no
16-byte alignment requirement) while ALL x86_64 Windows targets failed
(GetThreadContext/SetThreadContext return 0 on misaligned CONTEXT).

Fix: Use a #[repr(C, align(16))] wrapper (AlignedContext) to ensure
the CONTEXT struct is properly 16-byte aligned on x86_64.

Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/e3e0796e-c5d6-4538-92c8-b0fe0fd582af

Co-authored-by: loongs-zhang <38336731+loongs-zhang@users.noreply.github.com>

Author: Copilot

core/src/monitor.rs

@@ -223,6 +223,14 @@ impl Monitor {
             THREAD_SUSPEND_RESUME,
         };
 
+        // Windows API requires CONTEXT to be 16-byte aligned for
+        // GetThreadContext/SetThreadContext on x86_64. The windows-sys crate
+        // defines CONTEXT with #[repr(C)] (natural alignment 8), which is
+        // insufficient. This wrapper ensures proper alignment.
+        #[cfg(target_arch = "x86_64")]
+        #[repr(C, align(16))]
+        struct AlignedContext(CONTEXT);
+
         extern "C" {
             fn preempt_asm();
         }
@@ -242,24 +250,25 @@ impl Monitor {
                 return false;
             }
 
-            let mut context: CONTEXT = std::mem::zeroed();
             cfg_if::cfg_if! {
                 if #[cfg(target_arch = "x86_64")] {
-                    // CONTEXT_CONTROL for AMD64: only captures/restores control
+                    let mut aligned = AlignedContext(std::mem::zeroed());
+                    let context = &mut aligned.0;
+                    // CONTEXT_CONTROL for AMD64: captures/restores control
                     // registers (RIP, RSP, RBP, RFLAGS, segment registers).
                     // We only need to modify RIP and RSP to redirect the thread
-                    // to preempt_asm. The assembly itself saves and restores all
-                    // other registers (GPRs, XMMs, RFLAGS). Using CONTEXT_FULL
-                    // here would clobber registers that are in-use by the target
-                    // thread, causing SetThreadContext to corrupt thread state.
+                    // to preempt_asm. The assembly saves and restores all other
+                    // registers (GPRs, XMMs, RFLAGS).
                     context.ContextFlags = 0x0010_0001;
                 } else if #[cfg(target_arch = "x86")] {
+                    let mut context: CONTEXT = std::mem::zeroed();
+                    let context = &mut context;
                     // CONTEXT_CONTROL for i386
                     context.ContextFlags = 0x0001_0001;
                 }
             }
 
-            if GetThreadContext(handle, &raw mut context) == 0 {
+            if GetThreadContext(handle, &raw mut *context) == 0 {
                 _ = ResumeThread(handle);
                 _ = CloseHandle(handle);
                 return false;
@@ -295,7 +304,7 @@ impl Monitor {
                 }
             }
 
-            if SetThreadContext(handle, &raw const context) == 0 {
+            if SetThreadContext(handle, &raw const *context) == 0 {
                 _ = ResumeThread(handle);
                 _ = CloseHandle(handle);
                 return false;