feat: Family 06 Trend-Strength - 5 new directional/random-walk indicators (#44)

* feat(adxr): add Wilder Average Directional Movement Index Rating

ADXR is the trend-strength smoother Wilder published alongside ADX in
*New Concepts in Technical Trading Systems* (1978):

    ADXR_t = (ADX_t + ADX_{t - (period - 1)}) / 2

The lookback length is the same period that feeds the underlying ADX.
Because the older ADX is period - 1 bars stale, ADXR responds more
slowly than ADX and is the canonical metric for comparing
trend-strength across instruments.

Implementation reuses the existing wickra_core::Adx engine plus a
period-length ring of past ADX values; warmup is 3 * period - 1
(41 for period = 14). Bindings: Python PyAdxr (PyArray1 batch),
Node AdxrNode (number scalar), WASM WasmAdxr. Fuzz target covers
the candle-input path. Python + Node streaming-vs-batch tests
parametrised, plus a pure-uptrend reference value (ADXR == 100
when ADX saturates at 100). Criterion bench added under crates/
wickra/benches/indicators.rs.

README family table and indicator counter updated (71 -> 72).

* feat(rwi): add Mike Poulos Random Walk Index

RWI compares actual price displacement to what a random walk would
produce over the same horizon: for each lookback i in [2, period],

    RWI_High_t(i) = (high_t - low_{t-i+1}) / (ATR_i(t) * sqrt(i))
    RWI_Low_t(i)  = (high_{t-i+1} - low_t) / (ATR_i(t) * sqrt(i))

Per-bar output is the maximum across lookbacks for each direction;
a reading > 1 means the trend beats random-walk noise, > 2 is the
typical strong-trend threshold. Multi-output (high, low). period
must be >= 2 (the shortest meaningful lookback); period < 2 returns
InvalidPeriod. Warmup = period (e.g. 14 for the standard default).

Bindings: Python PyRwi (PyArray2 shape (n, 2)), Node RwiNode +
RwiValue struct, WASM WasmRwi (Object/Reflect for update,
Float64Array interleaved for batch). Fuzz target adds the candle
input case. Python parametric streaming-vs-batch test and pure
uptrend reference test (RWI_High dominates RWI_Low and exceeds 1).
Node parametric streaming-vs-interleaved-batch test. Criterion
bench under crates/wickra/benches/indicators.rs.

README family table and indicator counter updated (72 -> 73).

* feat(tii): add M.H. Pee Trend Intensity Index

TII is a [0, 100] oscillator that asks 'what fraction of the recent
SMA deviations are positive?'. The construction is

    dev_t  = close_t - SMA(close, sma_period)_t
    SD_pos = sum of positive dev_t over the last dev_period bars
    SD_neg = sum of |negative dev_t| over the last dev_period bars
    TII    = 100 * SD_pos / (SD_pos + SD_neg)

Saturates at 100 on a pure uptrend (every close above the lagging
SMA), at 0 on a pure downtrend, and returns the neutral mid-point 50
on a perfectly flat window. The output is clamped to [0, 100] as
the rolling-sum subtraction loop can accumulate a few ULP of error
on long histories. Canonical Pee parameters (sma_period=60,
dev_period=30) wired as Python defaults; warmup is
sma_period + dev_period - 1 (89 for the defaults).

Bindings: Python PyTii (PyArray1 batch), Node TiiNode (scalar
update + batch), WASM WasmTii via the two-arg wasm_scalar_indicator!
macro. Fuzz target adds the scalar path. Python parametric
streaming-vs-batch test plus pure-uptrend (TII == 100) and
flat-market (TII == 50) reference tests. Node parametric
streaming-vs-batch test. Criterion bench under crates/wickra/
benches/indicators.rs.

README family table and indicator counter updated (73 -> 74).

* feat(kst): add Pring Know Sure Thing oscillator

KST is Martin Pring's long-horizon momentum gauge: four smoothed
rate-of-change components combined with fixed weights (1, 2, 3, 4),
plus an SMA signal line.

    RCMA_i = SMA(ROC(close, roc_i), sma_i)        for i in 1..=4
    KST    = 1*RCMA_1 + 2*RCMA_2 + 3*RCMA_3 + 4*RCMA_4
    Signal = SMA(KST, signal_period)

Kst::classic() exposes Pring's recommended parameter set
(roc = (10, 15, 20, 30), sma = (10, 10, 10, 15), signal = 9);
warmup = max(roc_i + sma_i) + signal_period - 1 (53 for the classic
parameters). All four parallel branches are fed unconditionally so
they warm in lock-step.

Bindings: Python PyKst (PyArray2 shape (n, 2)) with a KST.classic()
staticmethod, Node KstNode + KstValue with a KST.classic() factory,
WASM WasmKst with both new(...) and classic() constructors plus
Object/Reflect for update and Float64Array for batch. Fuzz target
adds the scalar multi-output path. Python tests gain a new
MULTI_SCALAR section parametric over scalar-input/multi-output
indicators, plus a classic-on-constant-series reference test. Node
tests gain a KST entry in the multi-output section. Criterion
benchmark added under crates/wickra/benches/indicators.rs.

README family table and indicator counter updated (74 -> 75).

* feat(wave-trend): add LazyBear Wave Trend Oscillator

Two-line mean-reverting momentum gauge built from the typical price
and three cascaded EMAs:

    ap   = (high + low + close) / 3
    esa  = EMA(ap, channel_period)
    d    = EMA(|ap - esa|, channel_period)
    ci   = (ap - esa) / (0.015 * d)
    wt1  = EMA(ci, average_period)
    wt2  = SMA(wt1, signal_period)

WaveTrend::classic() exposes LazyBear's defaults
(channel = 10, average = 21, signal = 4); warmup is
2 * channel_period + average_period + signal_period - 3 (42 for the
classic defaults). On a perfectly flat market the SMA-seeded EMA
introduces a single-ULP drift between ap and esa, which on a tiny d
would make the ratio explode to -1/0.015 = -66.67; a price-scaled
flat-tolerance guard (d <= 16 * EPSILON * max(|esa|, 1)) collapses
the channel index to 0 in that regime so both lines remain at zero.

Bindings: Python PyWaveTrend (PyArray2 shape (n, 2)) with a
WaveTrend.classic() staticmethod, Node WaveTrendNode + WaveTrendValue
with a WaveTrend.classic() factory, WASM WasmWaveTrend with both
new(...) and classic() constructors. Fuzz target adds the candle
multi-output path (sorted alphabetically). Python parametric
streaming-vs-batch test plus a flat-market reference test. Node
parametric streaming-vs-interleaved-batch test. Criterion bench
under crates/wickra/benches/indicators.rs.

README family table and indicator counter updated (75 -> 76).

* fix(family-06): re-add KST::classic() factory + drop dup fuzz block

Family-06 PR's tests call ta.KST.classic() / wickra.KST.classic() — main's
KST binding shipped without the static factory. Add classic() in Python
(staticmethod) and Node (napi factory); WASM already had it. Also drop the
duplicate Kst::classic().unwrap() block in fuzz/indicator_update.rs that
the merge left behind (main's API no longer returns Result).

* test(rwi): drop dead count==0 guard

The loop `for i in 2..=period` makes `count = tr_end - tr_start = i - 1`
which is always >= 1, so the `if count == 0 { continue; }` branch was
unreachable defensive code that codecov flagged on the family-06 PR.

bindings/python/tests/test_new_indicators.py

@@ -54,6 +54,7 @@ SCALAR = [
     (ta.CMO, (14,)),
     (ta.TSI, (25, 13)),
     (ta.PMO, (35, 20)),
+    (ta.TII, (20, 10)),
     (ta.StochRSI, (14, 14)),
     (ta.PPO, (12, 26)),
     (ta.APO, (12, 26)),
@@ -196,6 +197,10 @@ CANDLE_SCALAR = {
         lambda: ta.ChaikinVolatility(10, 10),
         lambda ind, h, l, c, v: ind.batch(h, l),
     ),
+    "ADXR": (
+        lambda: ta.ADXR(7),
+        lambda ind, h, l, c, v: ind.batch(h, l, c),
+    ),
     "ParkinsonVolatility": (
         lambda: ta.ParkinsonVolatility(20, 252),
         lambda ind, h, l, c, v: ind.batch(h, l),
@@ -245,6 +250,11 @@ def test_candle_scalar_streaming_matches_batch(name, ohlcv):
 
 MULTI = {
     "Vortex": (lambda: ta.Vortex(14), lambda ind, h, l, c, v: ind.batch(h, l, c)),
+    "RWI": (lambda: ta.RWI(14), lambda ind, h, l, c, v: ind.batch(h, l, c)),
+    "WaveTrend": (
+        lambda: ta.WaveTrend.classic(),
+        lambda ind, h, l, c, v: ind.batch(h, l, c),
+    ),
     "SuperTrend": (
         lambda: ta.SuperTrend(10, 3.0),
         lambda ind, h, l, c, v: ind.batch(h, l, c),
@@ -489,6 +499,66 @@ def test_linreg_angle_reference():
     assert out[4] == pytest.approx(45.0)
 
 
+def test_wave_trend_flat_market_yields_zero():
+    # On a perfectly flat market the flat-tolerance guard keeps both lines
+    # at exactly zero (otherwise the ratio ci = (ap - esa) / (0.015 * d)
+    # would explode on the first esa ULP).
+    out = ta.WaveTrend.classic().batch(
+        np.full(80, 10.0), np.full(80, 10.0), np.full(80, 10.0)
+    )
+    last = out[~np.isnan(out[:, 0])][-1]
+    assert last[0] == 0.0
+    assert last[1] == 0.0
+
+
+def test_kst_classic_constants_yield_zero():
+    out = ta.KST.classic().batch(np.full(120, 100.0))
+    last_row = out[~np.isnan(out[:, 0])][-1]
+    assert last_row[0] == pytest.approx(0.0)
+    assert last_row[1] == pytest.approx(0.0)
+
+
+def test_tii_pure_uptrend_saturates_at_100():
+    # On a strictly increasing series every close sits above the lagging
+    # SMA, so every deviation is positive and TII reaches 100.
+    prices = np.arange(80, dtype=np.float64) + 100.0
+    out = ta.TII(10, 5).batch(prices)
+    last = out[~np.isnan(out)][-1]
+    assert last == pytest.approx(100.0)
+
+
+def test_tii_flat_market_yields_50():
+    out = ta.TII(5, 4).batch(np.full(30, 10.0))
+    last = out[~np.isnan(out)][-1]
+    assert last == 50.0
+
+
+def test_rwi_reference_uptrend_dominates_low_line():
+    # In a pure linear uptrend RWI_High >> RWI_Low.
+    n = 60
+    base = np.arange(n, dtype=np.float64) * 2.0 + 100.0
+    high = base + 1.0
+    low = base - 0.5
+    close = base + 0.5
+    out = ta.RWI(14).batch(high, low, close)
+    last_row = out[~np.isnan(out[:, 0])][-1]
+    assert last_row[0] > last_row[1], f"RWI_High {last_row[0]} must dominate RWI_Low {last_row[1]}"
+    assert last_row[0] > 1.0
+
+
+def test_adxr_reference_on_pure_uptrend():
+    # On a pure linear uptrend ADX saturates at 100, so ADXR (average of two
+    # saturated ADX values period-1 bars apart) also reads 100.
+    n = 100
+    base = np.arange(n, dtype=np.float64) * 2.0 + 100.0
+    high = base + 1.0
+    low = base - 0.5
+    close = base + 0.5
+    out = ta.ADXR(5).batch(high, low, close)
+    last = out[~np.isnan(out)][-1]
+    assert last == pytest.approx(100.0)
+
+
 def test_z_score_reference():
     # Window [1, 3]: mean 2, population stddev 1; latest 3 -> z = 1.
     out = ta.ZScore(2).batch(np.array([1.0, 3.0]))