Fix Windows CI: revert to CONTEXT_CONTROL for GetThreadContext/SetThreadContext

CONTEXT_FULL was corrupting the target thread's register state because
SetThreadContext would overwrite all integer and floating-point registers
with the captured (but potentially stale) values. Since our preempt_asm
assembly already saves and restores ALL registers (GPRs, XMMs, RFLAGS),
we only need CONTEXT_CONTROL to redirect RIP/RSP to preempt_asm.

The previous coroutine_preemptive timeout with CONTEXT_CONTROL was caused
by the monitor retrying preemption on already-preempted threads (the
double-preemption bug fixed in commit 445f5ea). With that fix in place,
CONTEXT_CONTROL is correct and sufficient.

Agent-Logs-Url: https://github.com/acl-dev/open-coroutine/sessions/9f2a2552-802a-4dff-8448-e97277e5ac70

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

Author: Copilot

core/src/monitor.rs

@@ -245,16 +245,17 @@ impl Monitor {
             let mut context: CONTEXT = std::mem::zeroed();
             cfg_if::cfg_if! {
                 if #[cfg(target_arch = "x86_64")] {
-                    // CONTEXT_FULL for AMD64: saves control + integer + floating-point
-                    // registers. Using CONTEXT_FULL (not just CONTEXT_CONTROL) ensures
-                    // all register state is properly round-tripped through
-                    // GetThreadContext/SetThreadContext, avoiding subtle issues in
-                    // release builds where CONTEXT_CONTROL alone may not capture
-                    // enough state for correct preemption.
-                    context.ContextFlags = 0x0010_000B;
+                    // CONTEXT_CONTROL for AMD64: only 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.
+                    context.ContextFlags = 0x0010_0001;
                 } else if #[cfg(target_arch = "x86")] {
-                    // CONTEXT_FULL for i386
-                    context.ContextFlags = 0x0001_000B;
+                    // CONTEXT_CONTROL for i386
+                    context.ContextFlags = 0x0001_0001;
                 }
             }