feat: add full derivatives analytics layer (options + futures)

Implements all phases of the derivatives expansion plan:

Rust core (crates/ferro_ta_core/src/options/, src/futures/):
- BSM and Black-76 pricing (scalar + vectorized batch)
- Greeks: delta, gamma, vega, theta, rho
- Implied volatility solver (Newton + bisection fallback)
- Smile/skew metrics: ATM IV, 25-delta RR/BF, skew slope, convexity
- Chain helpers: moneyness labels, strike selection by offset or delta
- Synthetic forwards, basis, annualized basis, implied carry, carry spread
- Continuous contract stitching: weighted, back-adjusted, ratio-adjusted
- Curve analytics: calendar spreads, slope, contango/backwardation summary

PyO3 bindings (src/options/, src/futures/):
- All Rust functions registered and exposed via _ferro_ta extension

Python API (python/ferro_ta/analysis/):
- options.py: pricing, greeks, IV, smile, chain, legacy iv_rank/percentile/zscore
- futures.py: basis, carry, curve, roll, synthetic, continuous contracts
- options_strategy.py: typed strategy schemas (expiry/strike selectors, leg presets, risk controls, simulation limits)
- derivatives_payoff.py: multi-leg payoff aggregation and Greeks aggregation

Bug fix: wrap _to_f64 calls in iv_rank/iv_percentile/iv_zscore to raise
FerroTAInputError (not plain ValueError) for 2D array input.

Docs: derivatives.rst, derivatives-analytics.md, options-volatility.md,
quickstart.rst, index.rst, api/analysis.rst all updated.

Tests: 2053 pass, 12 skipped. All CI checks pass locally.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

benchmarks/test_derivatives_speed.py

@@ -0,0 +1,108 @@
+"""
+Derivatives benchmark hooks.
+
+These are intentionally optional and skip when `py_vollib` is unavailable.
+Run with:
+
+    uv run pytest benchmarks/test_derivatives_speed.py --benchmark-only -v
+"""
+
+from __future__ import annotations
+
+import importlib.util
+
+import numpy as np
+import pytest
+
+from ferro_ta.analysis.options import implied_volatility, option_price
+
+
+def _sample_chain(n: int = 1000) -> tuple[np.ndarray, ...]:
+    spot = np.linspace(90.0, 110.0, n)
+    strike = np.full(n, 100.0)
+    rate = np.full(n, 0.02)
+    time_to_expiry = np.full(n, 0.5)
+    volatility = np.full(n, 0.2)
+    return spot, strike, rate, time_to_expiry, volatility
+
+
+def test_ferro_ta_option_price_speed(benchmark):
+    spot, strike, rate, time_to_expiry, volatility = _sample_chain()
+
+    benchmark.pedantic(
+        lambda: option_price(
+            spot,
+            strike,
+            rate,
+            time_to_expiry,
+            volatility,
+            option_type="call",
+            model="bsm",
+        ),
+        iterations=5,
+        rounds=20,
+        warmup_rounds=2,
+    )
+
+
+def test_ferro_ta_implied_vol_speed(benchmark):
+    spot, strike, rate, time_to_expiry, volatility = _sample_chain()
+    prices = option_price(
+        spot,
+        strike,
+        rate,
+        time_to_expiry,
+        volatility,
+        option_type="call",
+        model="bsm",
+    )
+
+    benchmark.pedantic(
+        lambda: implied_volatility(
+            prices,
+            spot,
+            strike,
+            rate,
+            time_to_expiry,
+            option_type="call",
+            model="bsm",
+        ),
+        iterations=5,
+        rounds=20,
+        warmup_rounds=2,
+    )
+
+
+@pytest.mark.skipif(
+    importlib.util.find_spec("py_vollib") is None,
+    reason="py_vollib is optional",
+)
+def test_py_vollib_scalar_loop_baseline(benchmark):
+    from py_vollib.black_scholes_merton import black_scholes_merton as py_vollib_bsm
+    from py_vollib.black_scholes_merton.implied_volatility import (
+        implied_volatility as py_vollib_iv,
+    )
+
+    spot, strike, rate, time_to_expiry, volatility = _sample_chain(250)
+    prices = [
+        py_vollib_bsm("c", float(s), float(k), float(t), float(r), float(vol), 0.0)
+        for s, k, r, t, vol in zip(spot, strike, rate, time_to_expiry, volatility)
+    ]
+
+    benchmark.pedantic(
+        lambda: [
+            py_vollib_iv(
+                float(price),
+                "c",
+                float(s),
+                float(k),
+                float(t),
+                float(r),
+                0.0,
+            )
+            for price, s, k, r, t in zip(prices, spot, strike, rate, time_to_expiry)
+        ],
+        iterations=3,
+        rounds=10,
+        warmup_rounds=1,
+    )