feat(aura-engine,aura-cli): named param binding — sweep axes .axis()/.sweep() (0030 iter 2)

Bind a sweep's axes by name instead of by a positional GridSpace:

    bp.axis("sma_cross.fast", [2, 3]).axis("sma_cross.slow", [4, 5]).axis("scale", [0.5]).sweep(run)

The sweep half of spec 0030, completing the named-binding feature (#35). A pure
authoring layer over the existing GridSpace::new / sweep primitives; engine core
untouched (C1/C12/C19/C23).

This iteration:
- resolve_axes(): shares resolve's name->slot mapping (iter 1), adds the EmptyAxis
  check (the variant defined in iter 1 is now first constructed here) and a
  per-element axis kind-check (every element of each axis, first offending element
  in axis order). Its validation is a strict superset of GridSpace::new's
  (arity / non-empty / per-element kind), so SweepBinder::sweep's downstream
  GridSpace::new(...).expect(...) is infallible by construction — it can never
  panic on author input.
- Composite::axis -> SweepBinder -> SweepBinder::sweep (Result<SweepFamily, BindError>).
- The CLI sample sweep converted to the named form (behaviour-preserving).

Plan correction (verified by the orchestrator): the iteration plan said only the
GridSpace import was orphaned by the CLI conversion, but replacing the free
sweep(&grid, ..) call with the .sweep(..) method also orphans the free `sweep`
import — both were dropped from aura-cli to satisfy clippy -D warnings. The Scalar
import (from aura_core) stays used and was untouched.

Verified (run by the orchestrator): 6 new aura-engine tests green —
resolve_axes round-trip, EmptyAxis, MissingKnob, the per-element KindMismatch on a
mixed axis (the superset/no-panic guarantee), a builder no-panic wrong-kind test,
and a GridSpace .points() parity test; the two sweep JSON goldens
(sweep_report_renders_four_points_in_odometer_order + the cli_run integration
golden) green unchanged (name/value/order-preserving conversion); full
`cargo test --workspace` green and `cargo clippy --workspace --all-targets
-- -D warnings` clean.

refs #35

crates/aura-cli/src/main.rs

@@ -10,7 +10,7 @@ mod render;
 
 use aura_core::{Firing, Scalar, ScalarKind, Timestamp};
 use aura_engine::{
-    f64_field, summarize, sweep, BlueprintNode, Composite, Edge, FlatGraph, GridSpace, Harness,
+    f64_field, summarize, BlueprintNode, Composite, Edge, FlatGraph, Harness,
     OutField, ParamAlias, Role, RunManifest, RunReport, SourceSpec, SweepFamily, Target,
 };
 use aura_registry::{rank_by, Registry};
@@ -224,45 +224,41 @@ fn scalar_as_param_f64(s: &Scalar) -> f64 {
 /// bootstraps it under the point vector, runs it, and folds the drained sinks to
 /// metrics — the per-point closure the engine `sweep` drives disjointly.
 fn sweep_family() -> SweepFamily {
-    let space = sample_blueprint_with_sinks().0.param_space();
-    let grid = GridSpace::new(
-        &space,
-        vec![
-            vec![Scalar::I64(2), Scalar::I64(3)], // fast  ∈ {2, 3}
-            vec![Scalar::I64(4), Scalar::I64(5)], // slow  ∈ {4, 5}
-            vec![Scalar::F64(0.5)],               // scale ∈ {0.5}
-        ],
-    )
-    .expect("the built-in grid matches the sample param-space");
-    sweep(&grid, |point| {
-        let (bp, rx_eq, rx_ex) = sample_blueprint_with_sinks();
-        let mut h = bp
-            .bootstrap_with_params(point.to_vec())
-            .expect("grid points are kind-checked against param_space");
-        let prices = synthetic_prices();
-        let window = (
-            prices.first().expect("non-empty stream").0,
-            prices.last().expect("non-empty stream").0,
-        );
-        h.run(vec![prices]);
-        let equity = f64_field(&rx_eq.try_iter().collect::<Vec<_>>(), 0);
-        let exposure = f64_field(&rx_ex.try_iter().collect::<Vec<_>>(), 0);
-        let params = space
-            .iter()
-            .zip(point)
-            .map(|(ps, v)| (ps.name.clone(), scalar_as_param_f64(v)))
-            .collect();
-        RunReport {
-            manifest: RunManifest {
-                commit: option_env!("AURA_COMMIT").unwrap_or("unknown").to_string(),
-                params,
-                window,
-                seed: 0,
-                broker: "sim-optimal(pip_size=0.0001)".to_string(),
-            },
-            metrics: summarize(&equity, &exposure),
-        }
-    })
+    let bp = sample_blueprint_with_sinks().0;
+    let space = bp.param_space();
+    bp.axis("sma_cross.fast", [2, 3])
+        .axis("sma_cross.slow", [4, 5])
+        .axis("scale", [0.5])
+        .sweep(|point| {
+            let (bp, rx_eq, rx_ex) = sample_blueprint_with_sinks();
+            let mut h = bp
+                .bootstrap_with_params(point.to_vec())
+                .expect("grid points are kind-checked against param_space");
+            let prices = synthetic_prices();
+            let window = (
+                prices.first().expect("non-empty stream").0,
+                prices.last().expect("non-empty stream").0,
+            );
+            h.run(vec![prices]);
+            let equity = f64_field(&rx_eq.try_iter().collect::<Vec<_>>(), 0);
+            let exposure = f64_field(&rx_ex.try_iter().collect::<Vec<_>>(), 0);
+            let params = space
+                .iter()
+                .zip(point)
+                .map(|(ps, v)| (ps.name.clone(), scalar_as_param_f64(v)))
+                .collect();
+            RunReport {
+                manifest: RunManifest {
+                    commit: option_env!("AURA_COMMIT").unwrap_or("unknown").to_string(),
+                    params,
+                    window,
+                    seed: 0,
+                    broker: "sim-optimal(pip_size=0.0001)".to_string(),
+                },
+                metrics: summarize(&equity, &exposure),
+            }
+        })
+        .expect("the built-in named grid matches the sample param-space")
 }
 
 /// Render a sweep family as one `RunReport` JSON line per point. Test helper: