[formats,viewer] Decode grouped-pool XBG7 models; fix mesh routing + albedo

Revert the mis-guided "triangle STRIP" reading (a937779): XBG7 index
buffers are triangle LISTS (prim=4 in the GPU capture; stored-normal
agreement 1.000 as a list vs ~0.49 as a strip). Reinstate the
winding-consistency gate.

Crack the grouped-pool layout used by the hero ship and ~150 detailed
models. A resource's sub-meshes share one index pool (buffers 4-byte
aligned, in descriptor-marker order) followed by one vertex pool (each
vtx_count*stride, same order); the vertex pool is 4-byte aligned after
the index pool. The whole resource is derived from one anchored pivot:
  ib0 = vb0 - span - pad   (pad in 0..=3, alignment)
  ib[i] = align4(ib[i-1] + idx_count[i-1]*2)
  vb[i] = vb[i-1] + vtx_count[i-1]*stride
vb0 is found via the unit-normal vertex-run scan; the alignment is
confirmed by validating the LARGEST sub-mesh (most reliable), after
which the rest are read/validated. A single marker reduces this to the
existing adjacency anchor, so grouped generalises it.

Results (cross-checked against a Canary GPU draw-log capture of
DeltaSaber_T.xpr):
- DeltaSaber_T f001 = body + 7 detail parts = 8650 tris, every sub-mesh
  0-degenerate / full-coverage / winding-agreement 1.000.
- All 19 previously-declined weapon models now decode (they hit pad 2
  and/or lead with a tiny bracket that broke a markers[0] pivot). Corpus
  audit: 0/146 geometry files fail (was 19 -> flat-texture in the viewer).
- Stages unchanged (single-marker path is byte-identical; grouped falls
  back to the old anchor on failure). 7/7 disc tests green incl. the
  strict stage quality audit; new hero_ship_grouped_pool_decodes test.

Viewer: route by count_xbg7; --only matches an exact model name (so the
neutral pose renders without the mnv*/turn180 animation poses). Fix the
albedo matcher: match a sub-model to its _col map by entity stem
(e007_bdy_01 -> e007_col) instead of a full-name prefix, lifting stage
sub-model texturing from ~25% to ~95% (the rest were flat grey). Colour
correctness (channel order/sRGB) remains a separate dynamic-RE item.

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

crates/sylpheed-formats/tests/mesh_disc.rs

@@ -122,6 +122,85 @@ fn complex_body_mesh_is_declined_not_garbage() {
     }
 }
 
+/// The hero ship's **grouped-pool** layout decodes fully: `DeltaSaber_T.xpr`'s
+/// `f001` resource is one vertex+index pool shared by 8 sub-meshes (body + 7
+/// detail parts). Reversed statically and cross-checked against a Canary GPU
+/// draw-log capture — every sub-mesh's stored normals agree with its triangle
+/// winding (0 degenerate, full vertex coverage). This is the layout the old
+/// per-block adjacency anchor rendered as a spiky phantom.
+#[test]
+#[ignore = "requires extracted disc models — set SYLPHEED_RES3D"]
+fn hero_ship_grouped_pool_decodes() {
+    let Some(dir) = res3d_dir() else {
+        eprintln!("SKIP: resource3d dir not found (set SYLPHEED_RES3D)");
+        return;
+    };
+    let bytes = std::fs::read(dir.join("DeltaSaber_T.xpr")).unwrap();
+    let models = Xbg7Model::stage_models(&bytes);
+
+    // The neutral pose `f001` (the mnv*/turn180 resources are animation poses).
+    let f001 = models.iter().find(|m| m.name == "f001").expect("f001 decoded");
+    assert_eq!(f001.meshes.len(), 8, "body + 7 detail sub-meshes");
+    let (v, t) = f001.totals();
+    assert_eq!(v, 11607, "vertex total across sub-meshes");
+    assert_eq!(t, 8650, "triangle total (body 8187 + 7 parts)");
+
+    // Sub-mesh 0 is the body: exactly the draw-log-verified geometry.
+    let body = &f001.meshes[0];
+    assert_eq!(body.positions.len(), 10891);
+    assert_eq!(body.indices.len(), 24561);
+
+    for (i, m) in f001.meshes.iter().enumerate() {
+        // Every index in range.
+        assert!(
+            m.indices.iter().all(|&ix| (ix as usize) < m.positions.len()),
+            "sub{i}: index out of range"
+        );
+        // Correct alignment ⇒ unit normals, and the winding agrees with them
+        // (the decisive correctness signal, ~1.0, not the ~0.5 of a mis-carve).
+        let n = m.normals.len();
+        assert_eq!(n, m.positions.len(), "sub{i}: a normal per vertex");
+        let mean_nlen: f32 = m
+            .normals
+            .iter()
+            .map(|nv| (nv[0] * nv[0] + nv[1] * nv[1] + nv[2] * nv[2]).sqrt())
+            .sum::<f32>()
+            / n as f32;
+        assert!((mean_nlen - 1.0).abs() < 0.05, "sub{i}: mean |normal| {mean_nlen} ≠ 1");
+
+        let mut agree = 0usize;
+        let mut counted = 0usize;
+        for tri in m.indices.chunks_exact(3) {
+            let (a, b, c) = (tri[0] as usize, tri[1] as usize, tri[2] as usize);
+            let (pa, pb, pc) = (m.positions[a], m.positions[b], m.positions[c]);
+            let u = [pb[0] - pa[0], pb[1] - pa[1], pb[2] - pa[2]];
+            let w = [pc[0] - pa[0], pc[1] - pa[1], pc[2] - pa[2]];
+            let f = [
+                u[1] * w[2] - u[2] * w[1],
+                u[2] * w[0] - u[0] * w[2],
+                u[0] * w[1] - u[1] * w[0],
+            ];
+            if f[0] * f[0] + f[1] * f[1] + f[2] * f[2] < 1e-12 {
+                continue;
+            }
+            let sn = [
+                m.normals[a][0] + m.normals[b][0] + m.normals[c][0],
+                m.normals[a][1] + m.normals[b][1] + m.normals[c][1],
+                m.normals[a][2] + m.normals[b][2] + m.normals[c][2],
+            ];
+            if f[0] * sn[0] + f[1] * sn[1] + f[2] * sn[2] > 0.0 {
+                agree += 1;
+            }
+            counted += 1;
+        }
+        let na = agree as f32 / counted.max(1) as f32;
+        assert!(
+            na.max(1.0 - na) > 0.95,
+            "sub{i}: winding-vs-normal agreement {na} — mis-carved (should be ~1.0 or ~0.0)"
+        );
+    }
+}
+
 /// Stage containers decode multiple enemy/prop sub-models via content anchoring.
 /// Prints coverage; asserts the known-good Stage_S10 meshes decode with sane geometry.
 #[test]