feat(family-14): add 15 candlestick patterns (#53)

* feat(family-14): add 15 candlestick patterns

Introduces the Candlestick Patterns family (block A of the family-14 spec)
as scalar f64 indicators on Candle inputs. Each detector emits +1.0 for a
bullish reading, -1.0 for a bearish reading, and 0.0 when no pattern is
present. Doji is direction-less and emits +1.0 / 0.0 only.

New indicators (15):

- Doji
- Hammer
- InvertedHammer
- HangingMan
- ShootingStar
- Engulfing
- Harami
- MorningEveningStar (signed: +1.0 morning star, -1.0 evening star)
- ThreeSoldiersOrCrows (signed: +1.0 soldiers, -1.0 crows)
- PiercingDarkCloud (signed: +1.0 piercing, -1.0 dark cloud)
- Marubozu (signed: +1.0 bullish, -1.0 bearish, 5 percent shadow tolerance default)
- Tweezer (signed: +1.0 bottom, -1.0 top, 10 bps relative tolerance default)
- SpinningTop (direction-signed indecision)
- ThreeInside (confirmed Harami)
- ThreeOutside (confirmed Engulfing)

MVP scope notes:

- Pattern-shape check only, no trend filter applied. Caller combines with a
  trend indicator for actionable signals. Documented in every doc comment.
- Block B (Harmonic patterns) and block C (Chart patterns) remain
  out-of-scope and will follow when the pattern-detection framework (pivot
  detector, multi-bar state machines) lands.

Touched across all bindings: Python, Node, WASM. Fuzz target, Python tests
(streaming-vs-batch + reference values), Node tests (streaming-vs-batch +
reference values), and a representative bench subset (1-, 2- and 3-bar
patterns) added. README family table + indicator counter (71 -> 86, eight
-> nine families) and CHANGELOG [Unreleased] updated.

* fix(family-14): unpack MULTI values with *_ to handle 3-element tuples

* cov(family-14): cover Default impl cold paths and MorningEveningStar guard branches

bindings/node/src/lib.rs

@@ -8317,3 +8317,105 @@ impl OpeningRangeNode {
         Ok(out)
     }
 }
+// ============================== Candlestick Patterns ==============================
+//
+// All 15 patterns take Candles (open, high, low, close) and emit a signed f64
+// signal per bar: +1.0 bullish, -1.0 bearish, 0.0 no pattern. Doji is
+// direction-less and emits 0/+1 only.
+
+macro_rules! node_candle_pattern {
+    ($node:ident, $inner:ty, $js:literal) => {
+        #[napi(js_name = $js)]
+        pub struct $node {
+            inner: $inner,
+        }
+
+        impl Default for $node {
+            fn default() -> Self {
+                Self::new()
+            }
+        }
+
+        #[napi]
+        impl $node {
+            #[napi(constructor)]
+            pub fn new() -> Self {
+                Self {
+                    inner: <$inner>::new(),
+                }
+            }
+            #[napi]
+            pub fn update(
+                &mut self,
+                open: f64,
+                high: f64,
+                low: f64,
+                close: f64,
+            ) -> napi::Result<Option<f64>> {
+                let candle = wc::Candle::new(open, high, low, close, 0.0, 0).map_err(map_err)?;
+                Ok(self.inner.update(candle))
+            }
+            #[napi]
+            pub fn batch(
+                &mut self,
+                open: Vec<f64>,
+                high: Vec<f64>,
+                low: Vec<f64>,
+                close: Vec<f64>,
+            ) -> napi::Result<Vec<f64>> {
+                if open.len() != high.len() || high.len() != low.len() || low.len() != close.len() {
+                    return Err(NapiError::from_reason(
+                        "open, high, low, close must be equal length".to_string(),
+                    ));
+                }
+                let mut out = Vec::with_capacity(open.len());
+                for i in 0..open.len() {
+                    let candle = wc::Candle::new(open[i], high[i], low[i], close[i], 0.0, 0)
+                        .map_err(map_err)?;
+                    out.push(self.inner.update(candle).unwrap_or(f64::NAN));
+                }
+                Ok(out)
+            }
+            #[napi]
+            pub fn reset(&mut self) {
+                self.inner.reset();
+            }
+            #[napi(js_name = "isReady")]
+            pub fn is_ready(&self) -> bool {
+                self.inner.is_ready()
+            }
+            #[napi(js_name = "warmupPeriod")]
+            pub fn warmup_period(&self) -> u32 {
+                self.inner.warmup_period() as u32
+            }
+        }
+    };
+}
+
+node_candle_pattern!(DojiNode, wc::Doji, "Doji");
+node_candle_pattern!(HammerNode, wc::Hammer, "Hammer");
+node_candle_pattern!(InvertedHammerNode, wc::InvertedHammer, "InvertedHammer");
+node_candle_pattern!(HangingManNode, wc::HangingMan, "HangingMan");
+node_candle_pattern!(ShootingStarNode, wc::ShootingStar, "ShootingStar");
+node_candle_pattern!(EngulfingNode, wc::Engulfing, "Engulfing");
+node_candle_pattern!(HaramiNode, wc::Harami, "Harami");
+node_candle_pattern!(
+    MorningEveningStarNode,
+    wc::MorningEveningStar,
+    "MorningEveningStar"
+);
+node_candle_pattern!(
+    ThreeSoldiersOrCrowsNode,
+    wc::ThreeSoldiersOrCrows,
+    "ThreeSoldiersOrCrows"
+);
+node_candle_pattern!(
+    PiercingDarkCloudNode,
+    wc::PiercingDarkCloud,
+    "PiercingDarkCloud"
+);
+node_candle_pattern!(MarubozuNode, wc::Marubozu, "Marubozu");
+node_candle_pattern!(TweezerNode, wc::Tweezer, "Tweezer");
+node_candle_pattern!(SpinningTopNode, wc::SpinningTop, "SpinningTop");
+node_candle_pattern!(ThreeInsideNode, wc::ThreeInside, "ThreeInside");
+node_candle_pattern!(ThreeOutsideNode, wc::ThreeOutside, "ThreeOutside");