perturbation-sim: NaN/panic hardening sweep — total_cmp sorts, cascade NaN-abort, stats empty-guard

Foundation-hardening before the kanban↔Lance↔jitson wiring rides on it.

- NaN-panic fix: 20 `partial_cmp(...).unwrap()` sites across 14 example files
  replaced with `f64::total_cmp` (never panics; deterministic NaN order). The
  lib `src/` had none in non-test code — the foundation was not panicking; this
  hardens the example/probe surface (the "speaking errors").
- Cascade NaN-abort: `simulate_outage` now breaks if any `theta`/`flow` value is
  non-finite (matching the islanding-break style) — a NaN can neither propagate
  into the perturbation shape nor loop to max_rounds. The "timeout for NaN".
- stats.rs: empty-slice guard on `mean`/`pop_var` (0/0 = NaN). Currently
  unreachable (all callers validate len ≥ 2) but wired at the source so a future
  caller can't leak it.
- NaN-source audit (src/): eigen, flow, perturbation, resilience, rolling_floor
  float producers all already guarded (SPECTRAL_GAP_FLOOR / rel_tol / .max(eps)
  / filter) — verified, no change needed.
- clippy --all-targets: zero warnings (default build, no ndarray-simd/cranelift).
  cargo-machete: not installed; only dep is the optional feature-gated ndarray.
- 95 lib tests pass.

Disk-light: no cranelift/ndarray build touched.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01CcpLeEC3XK8Eye53GKBVvi

Author: claude

crates/perturbation-sim/examples/buffer.rs

@@ -214,7 +214,7 @@ fn main() {
     let mut weakest: Vec<(usize, f64, f64)> = (0..comps.len())
         .map(|ci| (ci, mean_buf[ci], lam2s[ci]))
         .collect();
-    weakest.sort_by(|a, b| a.1.partial_cmp(&b.1).unwrap());
+    weakest.sort_by(|a, b| a.1.total_cmp(&b.1));
     let mut first_yield = None;
     for (ci, buf, l2) in &weakest {
         let y = ketchup_yield(impulse, *buf);

crates/perturbation-sim/examples/calibrate.rs

@@ -88,7 +88,7 @@ fn quantize_rank_bits(col: &[f64], bits: u32) -> Vec<f64> {
     let n = col.len();
     let bins = (1usize << bits).min(n.max(1));
     let mut idx: Vec<usize> = (0..n).collect();
-    idx.sort_by(|&a, &b| col[a].partial_cmp(&col[b]).unwrap());
+    idx.sort_by(|&a, &b| col[a].total_cmp(&col[b]));
     let mut out = vec![0.0; n];
     for b in 0..bins {
         let s = b * n / bins;
@@ -142,7 +142,7 @@ fn main() {
             (e, d * d * grid.edges[e].susceptance)
         })
         .collect();
-    sens.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+    sens.sort_by(|a, b| b.1.total_cmp(&a.1));
     let k = 24.min(m);
     let step = (m / k).max(1);
     let cand: Vec<usize> = (0..k).map(|i| sens[(i * step).min(m - 1)].0).collect();

crates/perturbation-sim/examples/explore.rs

@@ -338,7 +338,7 @@ fn main() {
             (e, d * d * grid.edges[e].susceptance)
         })
         .collect();
-    sens.sort_by(|a, b| b.1.partial_cmp(&a.1).unwrap());
+    sens.sort_by(|a, b| b.1.total_cmp(&a.1));
     let top: Vec<usize> = sens.iter().take(12).map(|x| x.0).collect();
     let lam2_0 = gl[1];
     let dl1: std::collections::HashMap<usize, f64> = top

crates/perturbation-sim/examples/hhtl_levels.rs

@@ -74,7 +74,7 @@ fn median(mut v: Vec<f64>) -> f64 {
     if v.is_empty() {
         return 0.0;
     }
-    v.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    v.sort_by(|a, b| a.total_cmp(b));
     v[v.len() / 2]
 }
 

crates/perturbation-sim/examples/hhtl_resident.rs

@@ -150,7 +150,7 @@ fn main() {
         let seed = base
             .iter()
             .enumerate()
-            .max_by(|x, y| x.1.abs().partial_cmp(&y.1.abs()).unwrap())
+            .max_by(|x, y| x.1.abs().total_cmp(&y.1.abs()))
             .map(|(i, _)| i)
             .unwrap_or(0);
         let infight = simulate_outage(&sub, &p, seed, cfg).fraction_tripped;

crates/perturbation-sim/examples/iberian.rs

@@ -115,7 +115,7 @@ fn main() {
     let seed = base
         .iter()
         .enumerate()
-        .max_by(|a, b| a.1.abs().partial_cmp(&b.1.abs()).unwrap())
+        .max_by(|a, b| a.1.abs().total_cmp(&b.1.abs()))
         .map(|(i, _)| i)
         .unwrap();
 

crates/perturbation-sim/examples/meta_hops.rs

@@ -95,7 +95,7 @@ fn median(mut v: Vec<f64>) -> f64 {
     if v.is_empty() {
         return 0.0;
     }
-    v.sort_by(|a, b| a.partial_cmp(b).unwrap());
+    v.sort_by(|a, b| a.total_cmp(b));
     v[v.len() / 2]
 }
 
@@ -169,7 +169,7 @@ fn main() {
             let seed = base
                 .iter()
                 .enumerate()
-                .max_by(|x, y| x.1.abs().partial_cmp(&y.1.abs()).unwrap())
+                .max_by(|x, y| x.1.abs().total_cmp(&y.1.abs()))
                 .map(|(i, _)| i)
                 .unwrap_or(0);
             infs.push(simulate_outage(&sub, &p, seed, cfg).fraction_tripped);

crates/perturbation-sim/examples/modifier_validity.rs

@@ -131,7 +131,7 @@ fn main() {
             (e, d * d * grid.edges[e].susceptance)
         })
         .collect();
-    sens.sort_by(|x, y| y.1.partial_cmp(&x.1).unwrap());
+    sens.sort_by(|x, y| y.1.total_cmp(&x.1));
     let k = 30.min(m);
     let step = (m / k).max(1);
     let cand: Vec<usize> = (0..k).map(|i| sens[(i * step).min(m - 1)].0).collect();

crates/perturbation-sim/examples/reinforce.rs

@@ -95,7 +95,7 @@ fn main() {
             }
         }
     }
-    cands.sort_by(|x, y| y.2.partial_cmp(&x.2).unwrap());
+    cands.sort_by(|x, y| y.2.total_cmp(&x.2));
 
     println!("\n== Reinforcement: optimal 3rd corridor across the Cheeger seam ==");
     println!("  base λ₂ = {lam2:.3e}   (new-line susceptance b = {w_new:.3})");
@@ -141,7 +141,7 @@ fn main() {
         .collect();
     let seed = *seam
         .iter()
-        .max_by(|&&x, &&y| base[x].abs().partial_cmp(&base[y].abs()).unwrap())
+        .max_by(|&&x, &&y| base[x].abs().total_cmp(&base[y].abs()))
         .unwrap_or(&0);
     let cfg = CascadeConfig {
         max_rounds: 16,

crates/perturbation-sim/examples/resilience.rs

@@ -131,7 +131,7 @@ fn main() {
         .map(|(i, b)| (i, cert(&induced(&grid, b))))
         .collect();
     // Weakest compartment first = smallest λ₂ margin.
-    certs.sort_by(|a, b| a.1.lambda2.partial_cmp(&b.1.lambda2).unwrap());
+    certs.sort_by(|a, b| a.1.lambda2.total_cmp(&b.1.lambda2));
 
     println!(
         "\n== Per-compartment certificate ({} compartments, weakest λ₂ first) ==",