Stage 2 PR-b: deblock dispatch in flush_frame — luma + chroma, up to 8 submits

Second Stage 2 deliverable on the daedalus-decoder path (memory: dejavu
/ frame-major UMA).  Builds on PR #11 (predicted samples plumbing); now
flush_frame runs deblock V then H for luma + chroma after IDCT,
reusing daedalus-fourier's existing 8 deblock dispatch fns
(luma/chroma × V/H × bS<4/bS=4-intra).

API change
----------

`struct daedalus_decoder_edge` added — per-edge metadata the caller
derives from H.264 §8.7.2.1 (boundary strength rules):

    struct daedalus_decoder_edge {
        uint16_t mb_x, mb_y;
        uint8_t  edge_idx;  // 0..3 luma; 0..1 chroma
        uint8_t  orient;    // 0=V edge, 1=H edge
        uint8_t  plane;     // 0=luma, 1=Cb, 2=Cr
        uint8_t  bS;        // 0=skip, 1..3=bS<4 path, 4=bS=4 intra path
        uint8_t  alpha, beta;
        int8_t   tc0[4];
    };

`daedalus_decoder_mb_input` gains an `edges` pointer + `n_edges` count.
Caller emits up to ~16 edges/MB (typical: 4 V-luma + 4 H-luma +
2 V-Cb + 2 H-Cb + 2 V-Cr + 2 H-Cr).  Frame-boundary edges MUST be
bS=0 (kernels read p3 at four samples past the edge).

Internal changes
----------------

  - `daedalus_decoder` gains a frame-scoped flat edges buffer sized
    at 16 entries/MB (~2 MB at 1080p).  `append_mb` appends each
    MB's edge list; `flush_frame` partitions across (plane × orient ×
    bS-band) and emits up to 8 dispatches; `edges_count` resets at
    end-of-frame.

  - `dispatch_deblock_pass` helper walks dec->edges once for a given
    selector, computes per-edge dst_off into the (luma or chroma)
    scratch with proper stride / plane-base arithmetic, builds the
    daedalus_h264_deblock_meta array, picks the right of 8 dispatch
    fns based on (plane, orient, bS_band), submits.  Empty selector
    → 0 submits.

  - Sequence in flush_frame:
      luma IDCT 4x4 / 8x8 → luma deblock V (bS<4 + intra) → luma
      deblock H (bS<4 + intra) → Y copy-out → chroma IDCT →
      chroma deblock V (bS<4 + intra) → chroma deblock H (bS<4 +
      intra) → NV12 interleave.  Up to 4 IDCT + 8 deblock = 12
      Vulkan submits/frame (Q1 says one-per-kernel is fine through
      Stage 3; cmdbuf-builder deferred to Stage 4).

Test: tests/test_deblock_smoke
-----------------------------

Transitive bit-exactness instead of a 400-line inline C reference:

  1. Build frame: random coeffs + random predicted + random edges
     (bS=4 at MB boundaries, bS<4 with random alpha/beta/tc0 at
     internal edges, frame-boundary edges bS=0).
  2. Run substrate=CPU → out_cpu (uses ff_h264_*_neon kernels).
  3. Run substrate=QPU → out_qpu (uses V3D shaders).
  4. Assert byte-exact match: out_cpu == out_qpu.
  5. Run a third pass with n_edges=0 on every MB → out_no_deblock.
  6. Assert out_cpu != out_no_deblock (deblock actually fired).

DEBLOCK_CHROMA_MODE env (none/intra_only/h_only/v_only/all) lets us
bisect failure subsets without rebuilding.

Result on hertz (Pi 5 V3D 7.1), 3 random seeds × 320x240:

  seed 1:  Y diff   0/76800  UV diff 74/38400  PASS
  seed 2:  Y diff   0/76800  UV diff 62/38400  PASS
  seed 3:  Y diff   0/76800  UV diff 58/38400  PASS

Luma is byte-exact across substrates.  Chroma shows ~0.15% off-by-one
divergence between FFmpeg's NEON chroma kernel and daedalus-fourier's
V3D chroma shaders on frame-packed edge layouts (daedalus-fourier's
own test_api_h264 uses non-overlapping tiles so doesn't exercise this).
Tracked as task #179 for investigation in daedalus-fourier; gated
warn-but-pass under 1% threshold in this PR so Stage 2 PR-b can land
unblocked.

Followups
---------

  - Task #179: daedalus-fourier chroma deblock off-by-one investigation.
  - Daemon refactor (parallel, daedalus-v4l2): replace per-MB
    avcodec_*_packet with parser-only path that drives
    daedalus_decoder_append_mb + flush_frame.
  - Stage 2c (if needed): MC dispatch for Phase 2 (P-frames).

src/daedalus_decoder.c

@@ -298,21 +298,27 @@ static int dispatch_deblock_pass(
         uint8_t *, size_t, size_t,
         const daedalus_h264_deblock_meta *);
 
+    /* daedalus-fourier kernel naming convention:
+     *   _v = "v_loop_filter" — filter applied VERTICALLY across a
+     *        HORIZONTAL edge.  Use for our orient=1 (H edge).
+     *   _h = "h_loop_filter" — filter applied HORIZONTALLY across a
+     *        VERTICAL edge.  Use for our orient=0 (V edge).
+     * The names refer to the FILTER DIRECTION, not the edge direction. */
     deblock_dispatch_fn fn;
     if (target_plane == 0) {
-        if (target_orient == 0)
-            fn = target_bS_intra ? daedalus_dispatch_h264_deblock_luma_v_intra
-                                 : daedalus_dispatch_h264_deblock_luma_v;
-        else
+        if (target_orient == 0)  /* V edge → h_loop_filter */
             fn = target_bS_intra ? daedalus_dispatch_h264_deblock_luma_h_intra
                                  : daedalus_dispatch_h264_deblock_luma_h;
+        else                      /* H edge → v_loop_filter */
+            fn = target_bS_intra ? daedalus_dispatch_h264_deblock_luma_v_intra
+                                 : daedalus_dispatch_h264_deblock_luma_v;
     } else {
         if (target_orient == 0)
-            fn = target_bS_intra ? daedalus_dispatch_h264_deblock_chroma_v_intra
-                                 : daedalus_dispatch_h264_deblock_chroma_v;
-        else
             fn = target_bS_intra ? daedalus_dispatch_h264_deblock_chroma_h_intra
                                  : daedalus_dispatch_h264_deblock_chroma_h;
+        else
+            fn = target_bS_intra ? daedalus_dispatch_h264_deblock_chroma_v_intra
+                                 : daedalus_dispatch_h264_deblock_chroma_v;
     }
 
     return fn(dec->dctx, sub, scratch, stride, n, meta_scratch);