F7: add NATR, StdDev, Ulcer Index and Historical Volatility

Completes the F7 family (Volatility) end to end:

- Rust core: natr.rs (ATR as a percentage of close), std_dev.rs
  (rolling population standard deviation), ulcer_index.rs (RMS of
  trailing-high drawdowns — downside-only risk), historical_volatility.rs
  (annualised sample stddev of log returns). Each with a full Indicator
  impl, runnable doctest and reference / constant-series / warmup /
  reset / batch==streaming tests.
- Python: PyNatr / PyStdDev / PyUlcerIndex / PyHistoricalVolatility
  PyO3 classes + module registration + .pyi stubs.
- Node: StdDevNode / UlcerIndexNode via the scalar macro, explicit
  NatrNode and HistoricalVolatilityNode; index.d.ts and index.js updated.
- WASM: WasmStdDev / WasmUlcerIndex / WasmHistoricalVolatility via the
  scalar macro, explicit WasmNatr.
- Wiki: Indicator-Natr/StdDev/UlcerIndex/HistoricalVolatility.md plus
  rows in Indicators-Overview.md and entries in Home.md.

cargo fmt + clippy (core/wickra/data/wasm/node) clean; 350 core tests,
25 data tests and 49 doctests green.

crates/wickra-core/src/indicators/natr.rs

@@ -0,0 +1,185 @@
+//! Normalized Average True Range.
+
+use crate::error::Result;
+use crate::ohlcv::Candle;
+use crate::traits::Indicator;
+
+use super::Atr;
+
+/// Normalized Average True Range — [`Atr`] expressed as a percentage of price.
+///
+/// `Atr` reports volatility in raw price units, which makes its readings
+/// impossible to compare across instruments at different price levels. NATR
+/// fixes that by dividing by the current close:
+///
+/// ```text
+/// NATR = 100 · ATR / close
+/// ```
+///
+/// A NATR of `2.0` always means "the average true range is 2 % of price",
+/// whether the instrument trades at $10 or $10 000 — so NATR values are
+/// directly comparable, and stop distances or position sizes expressed as a
+/// NATR multiple behave consistently across a portfolio.
+///
+/// # Example
+///
+/// ```
+/// use wickra_core::{Candle, Indicator, Natr};
+///
+/// let mut indicator = Natr::new(14).unwrap();
+/// let mut last = None;
+/// for i in 0..80 {
+///     let base = 100.0 + f64::from(i);
+///     let candle =
+///         Candle::new(base, base + 2.0, base - 2.0, base, 10.0, i64::from(i)).unwrap();
+///     last = indicator.update(candle);
+/// }
+/// assert!(last.is_some());
+/// ```
+#[derive(Debug, Clone)]
+pub struct Natr {
+    atr: Atr,
+    last: Option<f64>,
+}
+
+impl Natr {
+    /// Construct a new NATR with the given ATR period.
+    ///
+    /// # Errors
+    ///
+    /// Returns [`crate::Error::PeriodZero`] if `period == 0`.
+    pub fn new(period: usize) -> Result<Self> {
+        Ok(Self {
+            atr: Atr::new(period)?,
+            last: None,
+        })
+    }
+
+    /// Configured period.
+    pub const fn period(&self) -> usize {
+        self.atr.period()
+    }
+
+    /// Current value if available.
+    pub const fn value(&self) -> Option<f64> {
+        self.last
+    }
+}
+
+impl Indicator for Natr {
+    type Input = Candle;
+    type Output = f64;
+
+    fn update(&mut self, candle: Candle) -> Option<f64> {
+        let atr = self.atr.update(candle)?;
+        let natr = if candle.close == 0.0 {
+            // NATR is undefined against a zero close.
+            0.0
+        } else {
+            100.0 * atr / candle.close
+        };
+        self.last = Some(natr);
+        Some(natr)
+    }
+
+    fn reset(&mut self) {
+        self.atr.reset();
+        self.last = None;
+    }
+
+    fn warmup_period(&self) -> usize {
+        self.atr.warmup_period()
+    }
+
+    fn is_ready(&self) -> bool {
+        self.last.is_some()
+    }
+
+    fn name(&self) -> &'static str {
+        "NATR"
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::traits::BatchExt;
+    use approx::assert_relative_eq;
+
+    fn candle(open: f64, high: f64, low: f64, close: f64, ts: i64) -> Candle {
+        Candle::new(open, high, low, close, 1.0, ts).unwrap()
+    }
+
+    #[test]
+    fn new_rejects_zero_period() {
+        assert!(Natr::new(0).is_err());
+    }
+
+    #[test]
+    fn warmup_period_matches_atr() {
+        let natr = Natr::new(14).unwrap();
+        assert_eq!(natr.warmup_period(), 14);
+    }
+
+    #[test]
+    fn natr_is_atr_over_close_as_percent() {
+        // NATR must equal 100 * ATR / close, bar for bar.
+        let candles: Vec<Candle> = (0..60)
+            .map(|i| {
+                let mid = 100.0 + (i as f64 * 0.3).sin() * 10.0;
+                candle(mid, mid + 3.0, mid - 3.0, mid + 1.0, i)
+            })
+            .collect();
+        let natr_out = Natr::new(14).unwrap().batch(&candles);
+        let atr_out = Atr::new(14).unwrap().batch(&candles);
+        for (i, (n, a)) in natr_out.iter().zip(atr_out.iter()).enumerate() {
+            match (n, a) {
+                (Some(nv), Some(av)) => {
+                    let want = 100.0 * av / candles[i].close;
+                    assert_relative_eq!(*nv, want, epsilon = 1e-9);
+                }
+                (None, None) => {}
+                _ => panic!("warmup mismatch at {i}"),
+            }
+        }
+    }
+
+    #[test]
+    fn flat_market_yields_zero() {
+        // No range -> ATR is 0 -> NATR is 0.
+        let mut natr = Natr::new(5).unwrap();
+        let candles: Vec<Candle> = (0..30)
+            .map(|i| candle(100.0, 100.0, 100.0, 100.0, i))
+            .collect();
+        for v in natr.batch(&candles).into_iter().flatten() {
+            assert_relative_eq!(v, 0.0, epsilon = 1e-12);
+        }
+    }
+
+    #[test]
+    fn reset_clears_state() {
+        let mut natr = Natr::new(5).unwrap();
+        let candles: Vec<Candle> = (0..20)
+            .map(|i| candle(100.0, 102.0, 98.0, 101.0, i))
+            .collect();
+        natr.batch(&candles);
+        assert!(natr.is_ready());
+        natr.reset();
+        assert!(!natr.is_ready());
+        assert_eq!(natr.update(candles[0]), None);
+    }
+
+    #[test]
+    fn batch_equals_streaming() {
+        let candles: Vec<Candle> = (0..80)
+            .map(|i| {
+                let mid = 100.0 + (i as f64 * 0.35).sin() * 9.0;
+                candle(mid, mid + 2.5, mid - 2.5, mid + 0.5, i)
+            })
+            .collect();
+        let batch = Natr::new(14).unwrap().batch(&candles);
+        let mut b = Natr::new(14).unwrap();
+        let streamed: Vec<_> = candles.iter().map(|c| b.update(*c)).collect();
+        assert_eq!(batch, streamed);
+    }
+}