test: replace wedge self-capture goldens with structural invariants

Retire the support_regression_wedge golden pair and its comparator
(support_golden_regression_wedge_tdd.rs); packet 213's lone-node emission
showed a self-capture can be re-blessed past a real regression. New
invariants in support_invariants_wedge_tdd.rs pin contiguity, per-layer
step bound, width monotonicity, mesh-bbox containment and byte
determinism. Amends TASK-163b-orca-ref tracking in
docs/07_implementation_status.md.

Author: AdelinoGP

crates/slicer-runtime/tests/common/support_wedge.rs

@@ -4,7 +4,7 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use slicer_ir::{ConfigValue, SupportPlanIR};
+use slicer_ir::ConfigValue;
 use slicer_runtime::run::PrepassContext;
 
 fn workspace_root() -> PathBuf {
@@ -73,89 +73,3 @@ pub fn prepare_wedge_context_with_overrides(
 
     ctx
 }
-
-pub fn branch_segment_count(plan: &SupportPlanIR) -> usize {
-    plan.entries.iter().map(|e| e.branch_segments.len()).sum()
-}
-
-pub fn branch_endpoints(plan: &SupportPlanIR) -> Vec<[f32; 3]> {
-    let mut endpoints: Vec<[f32; 3]> = plan
-        .entries
-        .iter()
-        .flat_map(|entry| {
-            entry.branch_segments.iter().flat_map(|seg| {
-                let first = seg
-                    .points
-                    .first()
-                    .expect("branch segment must have at least one point");
-                let last = seg
-                    .points
-                    .last()
-                    .expect("branch segment must have at least one point");
-                [[first.x, first.y, first.z], [last.x, last.y, last.z]]
-            })
-        })
-        .collect();
-    endpoints.sort_by(|a, b| {
-        a[0].partial_cmp(&b[0])
-            .unwrap_or(std::cmp::Ordering::Equal)
-            .then_with(|| a[1].partial_cmp(&b[1]).unwrap_or(std::cmp::Ordering::Equal))
-            .then_with(|| a[2].partial_cmp(&b[2]).unwrap_or(std::cmp::Ordering::Equal))
-    });
-    endpoints
-}
-
-pub fn parse_branch_count(s: &str) -> usize {
-    s.trim()
-        .parse()
-        .expect("branch count must be a valid integer")
-}
-
-pub fn parse_endpoints(s: &str) -> Vec<[f32; 3]> {
-    s.lines()
-        .filter(|l| !l.trim().is_empty())
-        .map(|line| {
-            let parts: Vec<f32> = line
-                .split_whitespace()
-                .map(|v| v.parse().expect("endpoint value must be a valid f32"))
-                .collect();
-            assert_eq!(
-                parts.len(),
-                3,
-                "each endpoint line must have exactly 3 values, got {}",
-                parts.len()
-            );
-            [parts[0], parts[1], parts[2]]
-        })
-        .collect()
-}
-
-pub fn symmetric_hausdorff(a: &[f32], b: &[f32]) -> f32 {
-    fn one_sided(from: &[f32], to: &[f32]) -> f32 {
-        if from.is_empty() || to.is_empty() {
-            return 0.0;
-        }
-        let mut max_dist = 0.0f32;
-        for i in (0..from.len()).step_by(3) {
-            let px = from[i];
-            let py = from[i + 1];
-            let pz = from[i + 2];
-            let mut min_dist_sq = f32::MAX;
-            for j in (0..to.len()).step_by(3) {
-                let dx = px - to[j];
-                let dy = py - to[j + 1];
-                let dz = pz - to[j + 2];
-                let d = dx * dx + dy * dy + dz * dz;
-                if d < min_dist_sq {
-                    min_dist_sq = d;
-                }
-            }
-            let d = min_dist_sq.sqrt();
-            if d > max_dist {
-                max_dist = d;
-            }
-        }
-        max_dist
-    }
-    one_sided(a, b).max(one_sided(b, a))
-}

crates/slicer-runtime/tests/integration/main.rs

@@ -54,7 +54,6 @@ mod region_split_dispatch_filter;
 mod run_pipeline_with_instrumentation_tdd;
 mod runtime_wiring_tdd;
 mod support_geometry_config_normalization_tdd;
-mod support_golden_regression_wedge_tdd;
 mod support_invariants_wedge_tdd;
 mod thin_wall_emission_tdd;
 mod threemf_paint_drop_on_modifier_tdd;