feat(core+host+driver+client): mid-stream cursor-render flip — host composites in the capture model

The cursor channel excluded the host pointer from the video for the
whole session, but the client only draws it under the DESKTOP mouse
model — flipping ⌃⌥⇧M to capture mid-stream left the session
pointer-blind (user-found). The fix makes render ownership LIVE state:

- wire: CursorRenderMode 0x51 (client→host, control stream) —
  client_draws: true = desktop model (host excludes + forwards),
  false = capture model / released (host composites, full fidelity —
  DWM on Windows incl. real XOR inversion, encoder blend on Linux).
  Sessions start client_draws=true (the pre-message behavior).
- host: control task stores the flag; the encode loop edge-detects it —
  forwarding + frame.cursor strip while the client draws, quiet
  forwarder + overlay-into-blend while composited. SessionPlan now
  grants blend CAPABILITY wherever the capture has a pointer (dropping
  the !cursor_forward gate) so the composite side needs no encoder
  rebuild; per-tick frame.cursor decides what is drawn.
- Windows: Capturer::set_cursor_forward → retained
  IOCTL_SET_CURSOR_FORWARD sender (proto v6) → driver (un)declares the
  IddCx hardware cursor on the LIVE monitor. Un-declare re-issues the
  setup with EMPTY caps (candidate mechanism — the DDI has no
  documented un-setup); resetup-on-commit is skipped while off, so a
  mode commit's software-cursor default is the fallback path. Failure
  against a pre-v6 driver logs and keeps declared-at-ADD behavior.
- SDL client: one edge-detected reconciler at the cursor pump site —
  desktop-active = client draws; capture model or released = host
  composites. Covers the chord, the M3 auto-flip, and engage/release.
- C ABI v12: punktfunk_connection_set_cursor_render (additive; wire
  version unchanged — pre-§8 hosts ignore the unknown message type).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

crates/pf-driver-proto/src/lib.rs

@@ -74,7 +74,12 @@ pub const fn interface_guid_fields() -> (u32, u16, u16, [u8; 8]) {
 /// the driver's cursor thread seqlock-publishes into. Nothing existing changed; the host gates
 /// the feature on the handshake-reported version (`>= 5`) and keeps composited-cursor behavior
 /// against older drivers.
-pub const PROTOCOL_VERSION: u32 = 5;
+/// v6: ADDITIVE — [`control::IOCTL_SET_CURSOR_FORWARD`] (the mid-stream cursor-render flip,
+/// remote-desktop-sweep §8): the client's mouse-model flip (un)declares the hardware cursor on a
+/// LIVE monitor, so the capture mouse model gets DWM's composited pointer back (full fidelity)
+/// and the desktop model gets exclusion + forwarding. Nothing existing changed; against a v5
+/// driver the unknown IOCTL fails and the host logs + keeps the declared-at-ADD behavior.
+pub const PROTOCOL_VERSION: u32 = 6;
 
 /// The OLDEST driver protocol this host still drives (v4 is additive over v3 — see the v4 note on
 /// [`PROTOCOL_VERSION`]): a v3 driver lacks only `IOCTL_UPDATE_MODES`, which the host gates on the
@@ -126,6 +131,14 @@ pub mod control {
     /// `IddCxMonitorSetupHardwareCursor`, and starts its cursor-query thread. Input
     /// [`SetCursorChannelRequest`].
     pub const IOCTL_SET_CURSOR_CHANNEL: u32 = ctl_code(0x908);
+    /// Flip a LIVE monitor's hardware-cursor declaration (v6, the mid-stream cursor-render
+    /// flip): `enable = 1` re-declares (`IddCxMonitorSetupHardwareCursor` — DWM excludes the
+    /// pointer, the query/shape machinery resumes), `enable = 0` un-declares (the driver stops
+    /// re-declaring on mode commits and asks the OS to revert to the software cursor — DWM
+    /// composites the pointer into the frame, the pre-channel behavior the capture mouse
+    /// model wants). Only meaningful for a monitor whose cursor channel was delivered. Input
+    /// [`SetCursorForwardRequest`].
+    pub const IOCTL_SET_CURSOR_FORWARD: u32 = ctl_code(0x909);
 
     /// `IOCTL_ADD` input. A monotonic `session_id` keys the monitor (the host's refcount manager owns
     /// collision safety — no more SudoVDA's 16-byte GUID + pid-mangling). The driver advertises this
@@ -285,6 +298,17 @@ pub mod control {
         pub header_handle: u64,
     }
 
+    /// `IOCTL_SET_CURSOR_FORWARD` input (v6): the mid-stream cursor-render flip for one monitor.
+    #[repr(C)]
+    #[derive(Clone, Copy, Pod, Zeroable, Debug, PartialEq, Eq)]
+    pub struct SetCursorForwardRequest {
+        /// The OS target id from [`AddReply`] — which monitor to flip.
+        pub target_id: u32,
+        /// `1` = declare the hardware cursor (exclude + forward), `0` = un-declare (DWM
+        /// composites — the capture mouse model).
+        pub enable: u32,
+    }
+
     // Layout is load-bearing across the process boundary — pin it. (bytemuck's Pod derive already
     // rejects any internal padding; these assert the externally-visible sizes too.) The `offset_of!`
     // asserts additionally catch a SAME-SIZE field reorder, which the size+Pod checks alone miss.
@@ -326,6 +350,9 @@ pub mod control {
         assert!(size_of::<SetCursorChannelRequest>() == 16);
         assert!(offset_of!(SetCursorChannelRequest, target_id) == 0);
         assert!(offset_of!(SetCursorChannelRequest, header_handle) == 8);
+        assert!(size_of::<SetCursorForwardRequest>() == 8);
+        assert!(offset_of!(SetCursorForwardRequest, target_id) == 0);
+        assert!(offset_of!(SetCursorForwardRequest, enable) == 4);
 
         assert!(size_of::<UpdateModesRequest>() == 24);
         assert!(offset_of!(UpdateModesRequest, session_id) == 0);