feat(protocol,host): negotiate video codec + add a GPU-less software (openh264) encode path

Phase 1 of codec negotiation, and the Linux software H.264 encode path it unblocks.

**Codec negotiation (core `quic`):**
- `Hello.video_codecs` (bitfield: CODEC_H264/HEVC/AV1) — the client advertises what it can
  decode; appended as a trailing byte (older client → 0 = HEVC-only, back-compat).
- `Welcome.codec` — the single codec the host resolved and will emit; trailing byte (older
  host → HEVC).
- `resolve_codec(client, host_capable)` picks the shared codec (precedence HEVC > AV1 > H.264)
  or `None` → the host refuses honestly rather than sending an undecodable stream.
- Roundtrip + back-compat tests; cbindgen exports the CODEC_* constants.

**Software encoder (host):**
- The openh264 `OpenH264Encoder` (was Windows-only) is now built on Linux too — it's
  platform-agnostic (consumes CPU RGB `CapturedFrame`s, statically-bundled openh264). `openh264`
  moved to the shared linux+windows Cargo target.
- `PUNKTFUNK_ENCODER=software` selects it: `open_video` gains a `software` branch (H.264 only),
  and `session_plan::resolve_encoder` / `capture::gpu_encode` resolve `EncoderBackend::Software`
  → `output_format().gpu = false`, so the portal capturer delivers CPU RGB. Explicit-only (auto
  never picks it — a box with a dead driver still has /dev/nvidiactl and would mis-resolve NVENC).

**Host codec resolution (`punktfunk1`):**
- The native path no longer hardcodes HEVC: it resolves the codec from the client's advertised
  set ∩ the host's capability (`Codec::host_wire_caps`: software→H.264, else HEVC), threads it
  through `SessionPlan.codec`, and opens the encoder + validates reconfigures at that codec. A
  software host + HEVC-only client is refused with a clear error.
- 4:4:4 is gated on HEVC (it's HEVC-only).

**Probe:** advertises H264|HEVC|AV1 and logs the resolved codec.

Validated on the GPU-less dev box: negotiation is live end-to-end (probe advertises 0x07 → host
resolves H.264 → Welcome reports it → plan = Software/H264), and the openh264 unit test (CPU RGB →
AnnexB IDR) now runs on Linux. Full capture→encode still needs a GPU on this box — every
compositor screencast path (KWin GL, gamescope VK_EXT_physical_device_drm, wlroots EGL) requires
one; software render (llvmpipe/pixman) can't be captured — so this box exercises negotiation +
encoder, not live capture. The software path unblocks GPU-less-*encode* boxes that still have a
display GPU. Phase 2 (clients advertising real codecs + decoding per Welcome.codec) is a follow-up.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

crates/punktfunk-host/src/encode.rs

@@ -57,6 +57,37 @@ impl ChromaFormat {
 }
 
 impl Codec {
+    /// Map a negotiated `quic` codec bit ([`punktfunk_core::quic::CODEC_H264`] etc.) to the encoder
+    /// [`Codec`]. Unknown / `0` → HEVC (the pre-negotiation default). Inverse of [`Codec::to_wire`].
+    pub fn from_wire(bit: u8) -> Codec {
+        match bit {
+            punktfunk_core::quic::CODEC_H264 => Codec::H264,
+            punktfunk_core::quic::CODEC_AV1 => Codec::Av1,
+            _ => Codec::H265,
+        }
+    }
+
+    /// The single `quic` codec bit for this codec (echoed in [`punktfunk_core::quic::Welcome::codec`]).
+    pub fn to_wire(self) -> u8 {
+        match self {
+            Codec::H264 => punktfunk_core::quic::CODEC_H264,
+            Codec::H265 => punktfunk_core::quic::CODEC_HEVC,
+            Codec::Av1 => punktfunk_core::quic::CODEC_AV1,
+        }
+    }
+
+    /// The `quic` codec bitfield the host can currently **emit** on the punktfunk/1 native path,
+    /// given the resolved encode backend. The GPU-less software encoder (openh264) produces H.264
+    /// only; every GPU backend emits HEVC today (per-GPU H.264/AV1 negotiation on the native path is
+    /// future work — GameStream already negotiates codecs with Moonlight separately). Fed to
+    /// [`punktfunk_core::quic::resolve_codec`] against the client's advertised codecs.
+    pub fn host_wire_caps() -> u8 {
+        match crate::config::config().encoder_pref.as_str() {
+            "software" | "sw" | "openh264" => punktfunk_core::quic::CODEC_H264,
+            _ => punktfunk_core::quic::CODEC_HEVC,
+        }
+    }
+
     /// The FFmpeg NVENC encoder name (selected by name, not codec id — the latter would
     /// pick the software encoder).
     pub fn nvenc_name(self) -> &'static str {
@@ -283,6 +314,21 @@ pub fn open_video(
                 chroma,
             ),
             "vaapi" | "amd" | "intel" => open_vaapi(),
+            // GPU-less software H.264 (openh264) — for a headless / GPU-lost box. Explicit-only:
+            // `auto` never picks it (a box with `/dev/nvidiactl` present but a dead driver would
+            // otherwise wrongly resolve to NVENC). Needs H.264 (openh264 emits only that) and a CPU
+            // RGB frame, which the capturer delivers because the software backend resolves `gpu=false`.
+            "software" | "sw" | "openh264" => {
+                if codec != Codec::H264 {
+                    anyhow::bail!(
+                        "the software encoder emits H.264 only; the session negotiated {codec:?} \
+                         (a client must advertise CODEC_H264 to reach a software host)"
+                    );
+                }
+                let _ = (cuda, bit_depth); // software path is CPU + 8-bit only
+                sw::OpenH264Encoder::open(format, width, height, fps, bitrate_bps)
+                    .map(|e| Box::new(e) as Box<dyn Encoder>)
+            }
             "auto" | "" => {
                 // A CUDA frame can ONLY be consumed by NVENC, and a box with the NVIDIA device
                 // nodes always prefers it. Everything else (AMD/Intel) takes the VAAPI path.
@@ -303,7 +349,7 @@ pub fn open_video(
                 }
             }
             other => anyhow::bail!(
-                "unknown PUNKTFUNK_ENCODER={other:?} — use auto (default), nvenc, or vaapi"
+                "unknown PUNKTFUNK_ENCODER={other:?} — use auto (default), nvenc, vaapi, or software"
             ),
         }
     }
@@ -708,8 +754,10 @@ mod linux;
 #[cfg(all(target_os = "windows", feature = "nvenc"))]
 #[path = "encode/windows/nvenc.rs"]
 mod nvenc;
-#[cfg(target_os = "windows")]
-#[path = "encode/windows/sw.rs"]
+// Software (openh264) H.264 encoder — the GPU-less path on BOTH Windows and Linux (a headless /
+// GPU-less test box, or a fallback when no hardware encoder is available). Platform-agnostic: it
+// consumes CPU RGB `CapturedFrame`s and the statically-bundled openh264 build.
+#[cfg(any(target_os = "windows", target_os = "linux"))]
 mod sw;
 #[cfg(target_os = "linux")]
 #[path = "encode/linux/vaapi.rs"]