feat: M2 — KWin virtual-output backend behind a VirtualDisplay trait (native client resolution)

Honor the client's requested resolution by rendering a compositor virtual output at
exactly that size — native, headless, no scaling. There is no cross-compositor Wayland
protocol for this, so it's a per-compositor backend behind the (previously stubbed)
VirtualDisplay trait.

- vdisplay.rs: VirtualDisplay::create(mode) now returns a live VirtualOutput
  { node_id, remote_fd: Option<OwnedFd>, keepalive } with RAII teardown (drop releases
  the output) instead of an inert OutputHandle + explicit destroy. Add compositor
  detect() (LUMEN_COMPOSITOR / XDG_CURRENT_DESKTOP).
- vdisplay/kwin.rs: the KWin backend — the zkde_screencast_unstable_v1 stream_virtual_output
  client (vendored protocol XML + wayland-scanner codegen). Creates a WxH output, returns
  its PipeWire node (default daemon, remote_fd=None); a keepalive thread holds the Wayland
  connection until dropped. (Moved here from capture/kwin.rs — it's a vdisplay backend, not
  capture.)
- capture: generalize the PipeWire consumer to Option<OwnedFd> (portal remote vs. default
  daemon) and add capture_virtual_output(vout), compositor-agnostic, owning the keepalive.
- gamestream/stream.rs: LUMEN_VIDEO_SOURCE=virtual creates a virtual display sized to the
  client's cfg and captures it (self-contained, not pooled — a reconnect at a new
  resolution gets a fresh output).
- m0: --source kwin-virtual goes through the trait.

Verified end-to-end against the running headless KWin: the request reaches the compositor
and is handled cleanly. Native creation needs a backend implementing createVirtualOutput —
the DRM backend, or the VirtualBackend since KWin 6.5.6; on this box's --virtual 6.4.5 it
returns "Could not find output" (expected; validates after the KWin upgrade). wlroots/Mutter
backends are the next ones to land on the same seam.

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

crates/lumen-host/src/gamestream/stream.rs

@@ -77,6 +77,32 @@ fn run(
         .context("connect client video endpoint")?;
     tracing::info!(%client, "video: client endpoint learned");
 
+    // Native client-resolution source: create a compositor virtual output sized to the client's
+    // request and capture it (no scaling). Self-contained — deliberately NOT pooled in
+    // `video_cap`, since a reconnect at a different resolution needs a freshly-sized output; the
+    // output is released when this capturer drops at stream end (RAII via its keepalive).
+    if std::env::var("LUMEN_VIDEO_SOURCE").as_deref() == Ok("virtual") {
+        let compositor = crate::vdisplay::detect().context("detect compositor")?;
+        tracing::info!(
+            ?compositor,
+            w = cfg.width,
+            h = cfg.height,
+            "video source: virtual display (native client resolution)"
+        );
+        let mut vd = crate::vdisplay::open(compositor).context("open virtual display")?;
+        let vout = vd
+            .create(lumen_core::Mode {
+                width: cfg.width,
+                height: cfg.height,
+                refresh_hz: cfg.fps,
+            })
+            .context("create virtual output at client resolution")?;
+        let mut capturer =
+            capture::capture_virtual_output(vout).context("capture virtual output")?;
+        capturer.set_active(true);
+        return stream_body(&mut *capturer, &sock, cfg, running, force_idr);
+    }
+
     // Reuse the persistent capturer (one screencast session → clean reconnect); create it on
     // the first stream. Borrow it for this stream and return it on exit.
     let mut capturer: Box<dyn Capturer> = match video_cap.lock().unwrap().take() {