refactor(aura-engine): walk-forward param plane — space on family, tag-free chosen_params, schema-checked param_stability

Make the walk-forward param plane C7-clean and symmetric with the sweep param plane. WalkForwardResult gains `space: Vec<ParamSpec>` (the kinds, once, mirroring SweepFamily.space) and WindowRun.chosen_params changes Vec<Scalar> -> Vec<Cell> (the tag-free coordinate the inner sweep already produces). param_stability now resolves its numeric coercion once per slot against the schema (result.space) into a Vec<fn(Cell)->f64>, then runs a type-blind reduction loop — replacing the old per-window-value scalar_as_f64 with its per-value unreachable!. scalar_as_f64 is deleted.

This overturns cycle 0047's "Fork A" (chosen_params stays Vec<Scalar>), which was justified by Scalar's new serializability. That defense was moot: WalkForwardResult and WindowRun carry no serde derives — they are never serialized; only the embedded oos_report (a RunReport, typed via the 0047 lift) is. So chosen_params is a pure in-memory substrate for param_stability, and Vec<Scalar> made it C7-impure (carrying the kind N×M times at the value, where the kind is per-slot constant). The substantive case — kind at the schema, SweepFamily symmetry, per-value unreachable! eliminated — wins, the same argument-form that retired the {kind,cell} Scalar struct in 0047.

The seam ([A]): walk_forward / walk_forward_with_threads take `space: Vec<ParamSpec>` by value, a sibling of the run-window closure; the Fn(WindowBounds)->WindowRun+Sync bound is unchanged and run_indexed is untouched (space is never captured by the Sync closure, moved onto the result at the end). A debug_assert in walk_forward_with_threads guards the arity coupling (every window's chosen_params.len() == space.len(), guaranteed by the same blueprint). walkforward_family computes the space once before the roll and passes the tag-free winner (chosen_params: best.params) directly, dropping the from_cell+zip reconstruction.

[D]: a Bool param slot coerces to 0/1 (mean = fraction "on"), keeping the coercer total over the knob kinds; a Timestamp slot is structurally impossible (C20) so the schema pass carries one unreachable! (once per slot, never per value). param_stability keeps an `if result.windows.is_empty() { return Vec::new(); }` guard to preserve its documented empty-on-no-windows contract. WalkForwardResult and SweepFamily share the (space + tag-free Cell points + zip_params) idiom but stay distinct types — different axis (Sweep enumerates input coordinates; WF rolls time and chosen_params is the optimizer's output), and WF additionally carries bounds + oos_equity + stitched_oos_equity.

Behaviour-preserving (C1): the three migrated walk-forward tests stay green with identical MetricStats (param_stability_reduces_chosen_params_per_slot still pins mean 2.5 / p50 2.5 / mean 1.5); the i64->f64 and f64 coercions are value-identical to the deleted scalar_as_f64. The one genuinely new behaviour (Bool 0/1) is unexercised by built-in grids and pinned by the new param_stability_reduces_bool_slot_to_fraction_true (mean 0.75, 3-of-4 true).

Gates: build --workspace --all-targets, test --workspace, clippy --workspace --all-targets -D warnings, doc --workspace --no-deps — all clean.

closes #75

crates/aura-cli/src/main.rs

@@ -455,19 +455,15 @@ fn walkforward_family() -> WalkForwardResult {
     let span = window_of(&sources).expect("non-empty synthetic stream");
     let roller = WindowRoller::new(span, 24, 12, 12, RollMode::Rolling)
         .expect("built-in walk-forward config fits the 60-bar synthetic span");
-    walk_forward(roller, |w: WindowBounds| {
+    let space = sample_blueprint_with_sinks().0.param_space();
+    walk_forward(roller, space, |w: WindowBounds| {
         let is_family = sweep_over(w.is.0, w.is.1);
         let best = optimize(&is_family, "total_pips").expect("total_pips is a known metric");
         let (oos_equity, oos_report) = run_oos(&best.params, w.oos.0, w.oos.1);
         WindowRun {
-            // best.params is the enumerated cell winner; reconstruct the
-            // self-describing report record (Option A) via the in-sample space.
-            chosen_params: best
-                .params
-                .iter()
-                .zip(&is_family.space)
-                .map(|(c, ps)| Scalar::from_cell(ps.kind, *c))
-                .collect(),
+            // The tag-free sweep winner is the chosen point; its kinds live on
+            // WalkForwardResult.space (computed once above from the same blueprint).
+            chosen_params: best.params,
             oos_equity,
             oos_report,
         }