feat(train): Add ruvector integration — ADR-016, deps, DynamicPersonMatcher

- docs/adr/ADR-016: Full ruvector integration ADR with verified API details
  from source inspection (github.com/ruvnet/ruvector). Covers mincut,
  attn-mincut, temporal-tensor, solver, and attention at v2.0.4.
- Cargo.toml: Add ruvector-mincut, ruvector-attn-mincut, ruvector-temporal-
  tensor, ruvector-solver, ruvector-attention = "2.0.4" to workspace deps
  and wifi-densepose-train crate deps.
- metrics.rs: Add DynamicPersonMatcher wrapping ruvector_mincut::DynamicMinCut
  for subpolynomial O(n^1.5 log n) multi-frame person tracking; adds
  assignment_mincut() public entry point.
- proof.rs, trainer.rs, model.rs, dataset.rs, subcarrier.rs: Agent
  improvements to full implementations (loss decrease verification, SHA-256
  hash, LCG shuffle, ResNet18 backbone, MmFiDataset, linear interp).
- tests: test_config, test_dataset, test_metrics, test_proof, training_bench
  all added/updated. 100+ tests pass with no-default-features.

https://claude.ai/code/session_01BSBAQJ34SLkiJy4A8SoiL4

rust-port/wifi-densepose-rs/crates/wifi-densepose-train/src/subcarrier.rs

@@ -17,6 +17,8 @@
 //! ```
 
 use ndarray::{Array4, s};
+use ruvector_solver::neumann::NeumannSolver;
+use ruvector_solver::types::CsrMatrix;
 
 // ---------------------------------------------------------------------------
 // interpolate_subcarriers
@@ -118,6 +120,135 @@ pub fn compute_interp_weights(src_sc: usize, target_sc: usize) -> Vec<(usize, us
     weights
 }
 
+// ---------------------------------------------------------------------------
+// interpolate_subcarriers_sparse
+// ---------------------------------------------------------------------------
+
+/// Resample CSI subcarriers using sparse regularized least-squares (ruvector-solver).
+///
+/// Models the CSI spectrum as a sparse combination of Gaussian basis functions
+/// evaluated at source-subcarrier positions, physically motivated by multipath
+/// propagation (each received component corresponds to a sparse set of delays).
+///
+/// The interpolation solves: `A·x ≈ b`
+/// - `b`: CSI amplitude at source subcarrier positions `[src_sc]`
+/// - `A`: Gaussian basis matrix `[src_sc, target_sc]` — each row j is the
+///   Gaussian kernel `exp(-||target_k - src_j||^2 / sigma^2)` for each k
+/// - `x`: target subcarrier values (to be solved)
+///
+/// A regularization term `λI` is added to A^T·A for numerical stability.
+///
+/// Falls back to linear interpolation on solver error.
+///
+/// # Performance
+///
+/// O(√n_sc) iterations for n_sc subcarriers via Neumann series solver.
+pub fn interpolate_subcarriers_sparse(arr: &Array4<f32>, target_sc: usize) -> Array4<f32> {
+    assert!(target_sc > 0, "target_sc must be > 0");
+
+    let shape = arr.shape();
+    let (n_t, n_tx, n_rx, n_sc) = (shape[0], shape[1], shape[2], shape[3]);
+
+    if n_sc == target_sc {
+        return arr.clone();
+    }
+
+    // Build the Gaussian basis matrix A: [src_sc, target_sc]
+    // A[j, k] = exp(-((j/(n_sc-1) - k/(target_sc-1))^2) / sigma^2)
+    let sigma = 0.15_f32;
+    let sigma_sq = sigma * sigma;
+
+    // Source and target normalized positions in [0, 1]
+    let src_pos: Vec<f32> = (0..n_sc).map(|j| {
+        if n_sc == 1 { 0.0 } else { j as f32 / (n_sc - 1) as f32 }
+    }).collect();
+    let tgt_pos: Vec<f32> = (0..target_sc).map(|k| {
+        if target_sc == 1 { 0.0 } else { k as f32 / (target_sc - 1) as f32 }
+    }).collect();
+
+    // Only include entries above a sparsity threshold
+    let threshold = 1e-4_f32;
+
+    // Build A^T A + λI regularized system for normal equations
+    // We solve: (A^T A + λI) x = A^T b
+    // A^T A is [target_sc × target_sc]
+    let lambda = 0.1_f32; // regularization
+    let mut ata_coo: Vec<(usize, usize, f32)> = Vec::new();
+
+    // Compute A^T A
+    // (A^T A)[k1, k2] = sum_j A[j,k1] * A[j,k2]
+    // This is dense but small (target_sc × target_sc, typically 56×56)
+    let mut ata = vec![vec![0.0_f32; target_sc]; target_sc];
+    for j in 0..n_sc {
+        for k1 in 0..target_sc {
+            let diff1 = src_pos[j] - tgt_pos[k1];
+            let a_jk1 = (-diff1 * diff1 / sigma_sq).exp();
+            if a_jk1 < threshold { continue; }
+            for k2 in 0..target_sc {
+                let diff2 = src_pos[j] - tgt_pos[k2];
+                let a_jk2 = (-diff2 * diff2 / sigma_sq).exp();
+                if a_jk2 < threshold { continue; }
+                ata[k1][k2] += a_jk1 * a_jk2;
+            }
+        }
+    }
+
+    // Add λI regularization and convert to COO
+    for k in 0..target_sc {
+        for k2 in 0..target_sc {
+            let val = ata[k][k2] + if k == k2 { lambda } else { 0.0 };
+            if val.abs() > 1e-8 {
+                ata_coo.push((k, k2, val));
+            }
+        }
+    }
+
+    // Build CsrMatrix for the normal equations system (A^T A + λI)
+    let normal_matrix = CsrMatrix::<f32>::from_coo(target_sc, target_sc, ata_coo);
+    let solver = NeumannSolver::new(1e-5, 500);
+
+    let mut out = Array4::<f32>::zeros((n_t, n_tx, n_rx, target_sc));
+
+    for t in 0..n_t {
+        for tx in 0..n_tx {
+            for rx in 0..n_rx {
+                let src_slice: Vec<f32> = (0..n_sc).map(|s| arr[[t, tx, rx, s]]).collect();
+
+                // Compute A^T b [target_sc]
+                let mut atb = vec![0.0_f32; target_sc];
+                for j in 0..n_sc {
+                    let b_j = src_slice[j];
+                    for k in 0..target_sc {
+                        let diff = src_pos[j] - tgt_pos[k];
+                        let a_jk = (-diff * diff / sigma_sq).exp();
+                        if a_jk > threshold {
+                            atb[k] += a_jk * b_j;
+                        }
+                    }
+                }
+
+                // Solve (A^T A + λI) x = A^T b
+                match solver.solve(&normal_matrix, &atb) {
+                    Ok(result) => {
+                        for k in 0..target_sc {
+                            out[[t, tx, rx, k]] = result.solution[k];
+                        }
+                    }
+                    Err(_) => {
+                        // Fallback to linear interpolation
+                        let weights = compute_interp_weights(n_sc, target_sc);
+                        for (k, &(i0, i1, w)) in weights.iter().enumerate() {
+                            out[[t, tx, rx, k]] = src_slice[i0] * (1.0 - w) + src_slice[i1] * w;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    out
+}
+
 // ---------------------------------------------------------------------------
 // select_subcarriers_by_variance
 // ---------------------------------------------------------------------------
@@ -263,4 +394,21 @@ mod tests {
             assert!(idx < 20);
         }
     }
+
+    #[test]
+    fn sparse_interpolation_114_to_56_shape() {
+        let arr = Array4::<f32>::from_shape_fn((4, 1, 3, 114), |(t, _, rx, k)| {
+            ((t + rx + k) as f32).sin()
+        });
+        let out = interpolate_subcarriers_sparse(&arr, 56);
+        assert_eq!(out.shape(), &[4, 1, 3, 56]);
+    }
+
+    #[test]
+    fn sparse_interpolation_identity() {
+        // For same source and target count, should return same array
+        let arr = Array4::<f32>::from_shape_fn((2, 1, 1, 20), |(_, _, _, k)| k as f32);
+        let out = interpolate_subcarriers_sparse(&arr, 20);
+        assert_eq!(out.shape(), &[2, 1, 1, 20]);
+    }
 }