feat(std,cli): add the Scale node, retire the r-meanrev demo to data (#159 cut 3)

Cut 3 of the hard-wired demo retirement. Unlike r-sma/r-breakout, r-meanrev could
not round-trip as data: its band computes band_k*sigma (a constant times a stream)
and the closed 22-node std_vocabulary had no way to express it (EqConst is i64->bool,
Bias is clamp(signal/scale,±1), Mul is binary, LinComb is excluded as a
construction-arg node; no Div/Const/constant-emitter). Standard operators are missing
by chance, not by design, so this adds the one r-meanrev needs.

Scale node (aura-std): out = input * factor — one f64 input, one f64 `factor` param,
stateless, warm-up-filtered (the EqConst/Bias shape). A zero-input `Const` emitter was
rejected: the per-cycle eval loop gates every node through an input-firing test
(harness.rs `fires()`), so a node with no input never fires without an engine-core
change; `Scale` fits the existing model and, by IEEE-754 commutativity, reproduces the
retiring LinComb's band byte-for-byte. Rostered (`"Scale" => Scale`); the two
vocabulary count-pins bump 22 -> 23.

r-meanrev migration: r_meanrev_signal(window, band_k) is carved out of the fused
r_meanrev_graph as a #[cfg(test)] price->bias Composite whose band is `Scale` in place
of `LinComb(1)`; production loads the shipped JSON (examples/r_meanrev{,_open}.json),
never a builder. Before the fused builder was deleted, an equivalence test proved the
carved Scale-band signal reproduces its grade byte-for-byte on the synthetic stream
(window=3, band_k=2). Durable survivors: the byte-identity of the examples to the
carve, the loaded-grades-identically-to-carve proof, the closed/open introspect
anchors (mean_window.length, var_window.length, band.factor — band_k is now a
first-class sweepable param), and — re-pointed onto the carve rather than dropped —
the fades-short-above/long-below behavioural test, which becomes the durable
carve-correctness gate the deleted equivalence test used to be.

Deletions + the dead-code cascade the retirement opened: r_meanrev_graph,
r_meanrev_sweep_family, Strategy::RMeanRev (+ all arms). r-meanrev was the last reader
of run_sweep's grid, so the whole vestigial built-in-sweep grid apparatus retires with
it: run_sweep's `grid` param, the sweep call-site grid build, and SweepCmd's
--fast/--slow/--stop-length/--stop-k/--window/--band-k (sma/momentum sweeps build their
own blueprints and ignored these; the fast/slow/stop-* had been vestigial since r-sma's
cut 1b). RGrid the struct SURVIVES — the dissolved `generalize` verb resolves its
candidate from its fast/slow/stop_length/stop_k via generalize_args_from — so only its
window/band_k fields go; its stale doc-comment (r-sma-sweep / persist_traces_r / CLI
flags, all now gone) is rewritten to its true generalize-only role. Also retired as
transitively dead: persist_traces_r and the metrics_object test helper (their only
callers were the deleted families/tests); Add/Gt/Latch/Mul/Sqrt imports are now
#[cfg(test)] (their last production caller was r_meanrev_graph).

Test surface: the two built-in --strategy r-meanrev sweep tests drop; a new negative
pins that --strategy r-meanrev on both sweep and walkforward now falls into the generic
usage error; the grid-flag stray-positional negative is re-pointed to a surviving flag.

Verification (own, not the workflow's report): full `cargo test --workspace` green
(0 failed across 62 result lines); `cargo clippy --workspace --all-targets -- -D
warnings` clean, no dead-code residue; the r-sma + r-breakout anchors and the
dissolved-verb real goldens (generalize still reads RGrid) stay green. Bundled as one
commit (the Scale node's count-pin and the r-meanrev anchors share graph_construct.rs,
so a clean two-commit split was not path-separable); the implement-loop ran all three
plan tasks in one pass and the tree was verified by hand.

refs #159

crates/aura-std/src/lib.rs

@@ -38,6 +38,7 @@ mod recorder;
 mod resample;
 mod rolling_max;
 mod rolling_min;
+mod scale;
 mod series_reducer;
 mod session;
 mod sim_broker;
@@ -75,6 +76,7 @@ pub use recorder::Recorder;
 pub use resample::Resample;
 pub use rolling_max::RollingMax;
 pub use rolling_min::RollingMin;
+pub use scale::Scale;
 pub use series_reducer::SeriesReducer;
 pub use session::Session;
 pub use sim_broker::SimBroker;

crates/aura-std/src/scale.rs

@@ -0,0 +1,75 @@
+//! `Scale` — a stateless `f64 -> f64` multiply-by-constant: `out = input * factor`.
+//! The standard scalar-gain operator (the `*` is fixed by the type; `factor` is the
+//! only knob). One f64 input, one f64 output, allocation-free on the hot path.
+use aura_core::{
+    Cell, Ctx, FieldSpec, Firing, Node, NodeSchema, ParamSpec, PortSpec, PrimitiveBuilder,
+    ScalarKind,
+};
+
+/// Stateless scalar gain: emits `input * factor` each cycle. Emits `None` until its
+/// input is present (warm-up filter, C8).
+pub struct Scale {
+    factor: f64,
+    out: [Cell; 1],
+}
+
+impl Scale {
+    /// Build a gain node that multiplies its input by `factor`.
+    pub fn new(factor: f64) -> Self {
+        Self { factor, out: [Cell::from_f64(0.0)] }
+    }
+
+    /// The param-generic recipe for a blueprint primitive: declares `factor` and
+    /// builds through `Scale::new` (the slice is kind-checked before `build` runs).
+    pub fn builder() -> PrimitiveBuilder {
+        PrimitiveBuilder::new(
+            "Scale",
+            NodeSchema {
+                inputs: vec![PortSpec { kind: ScalarKind::F64, firing: Firing::Any, name: "signal".into() }],
+                output: vec![FieldSpec { name: "value".into(), kind: ScalarKind::F64 }],
+                params: vec![ParamSpec { name: "factor".into(), kind: ScalarKind::F64 }],
+            },
+            |p| Box::new(Scale::new(p[0].f64())),
+        )
+    }
+}
+
+impl Node for Scale {
+    fn lookbacks(&self) -> Vec<usize> {
+        vec![1]
+    }
+
+    fn eval(&mut self, ctx: Ctx<'_>) -> Option<&[Cell]> {
+        let w = ctx.f64_in(0);
+        if w.is_empty() {
+            return None; // not yet warmed up (C8 filter)
+        }
+        self.out[0] = Cell::from_f64(w[0] * self.factor);
+        Some(&self.out)
+    }
+
+    fn label(&self) -> String {
+        format!("Scale({})", self.factor)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use aura_core::{AnyColumn, Scalar, Timestamp};
+
+    #[test]
+    fn scale_multiplies_input_by_factor() {
+        let mut node = Scale::new(2.0);
+        let mut inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, node.lookbacks()[0])];
+        inputs[0].push(Scalar::f64(3.0)).unwrap();
+        assert_eq!(node.eval(Ctx::new(&inputs, Timestamp(0))), Some([Cell::from_f64(6.0)].as_slice()));
+    }
+
+    #[test]
+    fn scale_is_none_until_input_present() {
+        let mut node = Scale::new(2.0);
+        let inputs = vec![AnyColumn::with_capacity(ScalarKind::F64, 1)];
+        assert_eq!(node.eval(Ctx::new(&inputs, Timestamp(0))), None);
+    }
+}

crates/aura-std/src/vocabulary.rs

@@ -19,7 +19,7 @@
 
 use crate::{
     Add, And, Bias, CarryCost, ConstantCost, Delay, Ema, EqConst, FixedStop, Gt, Latch, LongOnly,
-    Mul, PositionManagement, Resample, RollingMax, RollingMin, Sizer, Sma, Sqrt, Sub,
+    Mul, PositionManagement, Resample, RollingMax, RollingMin, Scale, Sizer, Sma, Sqrt, Sub,
     VolSlippageCost,
 };
 use aura_core::PrimitiveBuilder;
@@ -75,6 +75,7 @@ std_vocabulary_roster! {
     "Resample" => Resample,
     "RollingMax" => RollingMax,
     "RollingMin" => RollingMin,
+    "Scale" => Scale,
     "Sizer" => Sizer,
     "SMA" => Sma,
     "Sqrt" => Sqrt,
@@ -123,7 +124,7 @@ mod tests {
         assert!(!std_vocabulary_types().contains(&"LinComb")); // construction-arg node
         assert!(!std_vocabulary_types().contains(&"Recorder")); // sink
         assert!(!std_vocabulary_types().contains(&"nope"));
-        // count guard: pins the roster at exactly 22 entries
-        assert_eq!(std_vocabulary_types().len(), 22);
+        // count guard: pins the roster at exactly 23 entries
+        assert_eq!(std_vocabulary_types().len(), 23);
     }
 }