test(pillar): wire Pillar 12 drift-check against splat3d::Spd3::from_scale_quat

Cross-validation test that runs both the pillar's
independently-derived covariance_from_scale_quat() AND the production
Spd3::from_scale_quat() on the same SplitMix64-seeded 256 (scale, quat)
pairs, then asserts upper-triangle agreement to within 1e-5 per lane.

This is the missing wire from #188's "Pillars 12-14 implemented":
the pillar files reference their production targets in docstrings but
do not cross-check against them. The PR description explicitly noted
this gap ("Production code paths in splat3d, dn_tree, ogit_bridge are
not coupled to pillars in this PR. The pillars re-derive their math
independently, by design — drift between substrate and pillar is the
failure mode pillars exist to catch.")

The cross-check below preserves that design — it adds NO coupling in
src/ — but it gates CI on production and pillar agreeing, so drift
WILL fail the build instead of silently passing both kernels.

For the other two implemented pillars in #188:
  - Pillar 13 needs `pub(crate) fn bundle_into` to be re-exported on
    `dn_tree` so a sibling cross-check can compare to production
    (currently private).
  - Pillar 14 needs a separable closure/ancestor accessor on
    `OntologySchema` (currently the closure is implicit in the
    heel→hip→leaf family-bitmap construction with no public
    point-pair `is_ancestor(t, u) -> bool` to validate against).

Both gaps require small production-side surface changes, which is a
better fit for the session that owns the pillar branch; this commit
wires only the gap that needed zero production change.

Author: claude

src/hpc/pillar/splat_invariants.rs

@@ -437,4 +437,56 @@ mod tests {
         assert!((r1.psd_rate - r2.psd_rate).abs() < 1e-12);
         assert!((r1.lognorm_concentration - r2.lognorm_concentration).abs() < 1e-12);
     }
+
+    /// Drift-detection: the pillar's `covariance_from_scale_quat`
+    /// independently re-derives `Σ = R(q) · diag(s²) · R(q)ᵀ`. The
+    /// production code path at `crate::hpc::splat3d::spd3::Spd3::from_scale_quat`
+    /// is the substrate the pillar is *defending*. This test runs both
+    /// on the same SplitMix64-seeded sample of 256 `(scale, quat)` pairs
+    /// and asserts agreement to within `1e-5` per upper-triangle entry.
+    ///
+    /// Any divergence ≥ ε indicates one of two failure modes:
+    ///   (a) production drifted from the canonical quaternion-rotation
+    ///       formula (the pillar definition wins by design — fix the
+    ///       production code), or
+    ///   (b) the pillar itself drifted (audit `covariance_from_scale_quat`
+    ///       against Kerbl 2023 Eq. 3 before changing).
+    ///
+    /// This is the *coupling* the per-pillar docstring promises:
+    /// production and pillar share no code, but they share a CI gate
+    /// that compares them point-for-point.
+    #[test]
+    fn pillar_12_matches_production_spd3_from_scale_quat() {
+        use crate::hpc::splat3d::spd3::Spd3;
+
+        const N: u32 = 256;
+        let mut rng = SplitMix64::new(PILLAR_12_SEED);
+        let mut max_abs_err: f32 = 0.0;
+
+        for _ in 0..N {
+            let s = [
+                sample_scale_axis(&mut rng),
+                sample_scale_axis(&mut rng),
+                sample_scale_axis(&mut rng),
+            ];
+            let q = sample_unit_quaternion(&mut rng);
+
+            let pillar = covariance_from_scale_quat(s, q);
+            let prod = Spd3::from_scale_quat(s, q);
+            let prod_ut = [prod.a11, prod.a12, prod.a13, prod.a22, prod.a23, prod.a33];
+
+            for (i, (&p, &pr)) in pillar.iter().zip(prod_ut.iter()).enumerate() {
+                let err = (p - pr).abs();
+                if err > max_abs_err {
+                    max_abs_err = err;
+                }
+                assert!(
+                    err < 1e-5,
+                    "Pillar/Spd3 drift at lane {i}: pillar={p:.7} prod={pr:.7} err={err:.2e} s={s:?} quat={q:?}"
+                );
+            }
+        }
+
+        eprintln!("Pillar 12 ↔ Spd3::from_scale_quat agreement: max_abs_err={max_abs_err:.3e} over {N} pairs");
+    }
 }