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-presenter/src/run.rs

@@ -242,6 +242,10 @@ struct StreamState {
     /// The user flipped the model manually (⌃⌥⇧M) — the standing hint stops driving until
     /// the HOST's intent next changes (a fresh hint edge clears this and applies).
     hint_override: bool,
+    /// Last `CursorRenderMode.client_draws` told to the host (§8 mid-stream render flip);
+    /// `None` = nothing sent yet. Edge-detected each iteration from the live mouse model, so
+    /// the chord, the M3 auto-flip, and engage/release all reconcile through one path.
+    sent_client_draws: Option<bool>,
 }
 
 impl StreamState {
@@ -275,6 +279,7 @@ impl StreamState {
             cursor_chan: None,
             last_hint: None,
             hint_override: false,
+            sent_client_draws: None,
             force_software,
             canceled: false,
             ready_announced: false,
@@ -774,6 +779,16 @@ fn run_inner(mut opts: SessionOpts, mut mode: ModeCtl) -> Result<Option<Outcome>
                     .as_ref()
                     .is_some_and(|cap| cap.captured() && cap.desktop());
                 chan.pump(c, &mouse, desktop_active);
+                // §8 mid-stream render flip: tell the host who renders the pointer whenever
+                // the local model changes. Desktop-active = we draw it (host excludes +
+                // forwards); anything else — the capture model OR a released pointer — the
+                // host composites it into the video (full fidelity, the pre-channel look).
+                // One edge-detected reconciler covers the chord, the M3 auto-flip, and
+                // engage/release alike.
+                if chan.negotiated() && st.sent_client_draws != Some(desktop_active) {
+                    st.sent_client_draws = Some(desktop_active);
+                    let _ = c.set_cursor_render(desktop_active);
+                }
             }
             // M3 — host-driven mode flip: `relative_hint` set = a host app grabbed/hid the
             // pointer (run captured relative, like a game expects); clear = the desktop is