perf: Fase 2 speed (3x baseline) - fuse JIT + LRU + sub-pixel lazy

Ottimizzazioni cumulative (225s -> 73s sul bench suite, 3.07x):

pm2d/line_matcher.py:
- Sub-pixel + plateau centroid spostati DOPO il pre-NMS (prima: 58k chiamate
  per clip_preciso anche su candidati poi scartati dalla NMS; ora solo sui
  ~75 preliminary sopravvissuti). Coordinate intere OK per la decisione
  reject, dato che nms_radius >= 8 px.
- Usa nuovo kernel fuso score+rescore (no allocazione intermedia).
- Adaptive plateau_radius + propagazione train_mask per NCC coerente.
- Local crop NCC (diag template invece di intera scena).
- Fallback adattivo se bg_rescore azzera tutti gli score top-level.

pm2d/_jit_kernels.py:
- Nuovo kernel _jit_score_bitmap_rescored: fonde scoring bitmap e rescore
  (score - bg) / (1 - bg) in un singolo pass parallelo. Evita allocazione
  e passata aggiuntiva (era ~15% del tempo find sul preciso).

pm2d/auto_tune.py:
- LRU cache in-memory sui risultati auto_tune (chiave md5 ROI + mask):
  richiamate successive con stessa ROI sono O(1).
- Downsample a 128px prima della correlazione rotazionale
  (O(n_angles * H * W) -> insensibile su sample moderati).
- Soglie weak/strong da percentili reali (p55/p85) senza clamp a 100,
  con clamp massimo 400 per evitare saturazione su template ad alto contrasto.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

pm2d/_jit_kernels.py

@@ -110,6 +110,55 @@ if HAS_NUMBA:
                     acc[y, x] *= inv
         return acc
 
+    @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
+    def _jit_score_bitmap_rescored(
+        spread: np.ndarray,      # uint8 (H, W)
+        dx: np.ndarray,          # int32 (N,)
+        dy: np.ndarray,          # int32 (N,)
+        bins: np.ndarray,        # int8 (N,)
+        bit_active: np.uint8,
+        bg: np.ndarray,          # float32 (H, W) background density normalizzata
+    ) -> np.ndarray:
+        """score+rescore in un singolo pass: evita allocazione intermedia.
+
+        Equivalente a:
+            score = _jit_score_bitmap(...)
+            out   = max(0, (score - bg) / (1 - bg + 1e-6))
+        ma fonde la seconda passata dentro la normalizzazione finale
+        (cache-friendly, risparmia ~15% sul totale find).
+        """
+        H, W = spread.shape
+        N = dx.shape[0]
+        acc = np.zeros((H, W), dtype=np.float32)
+        for y in nb.prange(H):
+            for i in range(N):
+                b = bins[i]
+                mask = np.uint8(1) << b
+                if (bit_active & mask) == 0:
+                    continue
+                ddy = dy[i]
+                yy = y + ddy
+                if yy < 0 or yy >= H:
+                    continue
+                ddx = dx[i]
+                x_lo = 0 if ddx >= 0 else -ddx
+                x_hi = W if ddx <= 0 else W - ddx
+                for x in range(x_lo, x_hi):
+                    if spread[yy, x + ddx] & mask:
+                        acc[y, x] += 1.0
+        if N > 0:
+            inv = 1.0 / N
+            for y in nb.prange(H):
+                for x in range(W):
+                    v = acc[y, x] * inv
+                    bgv = bg[y, x]
+                    if bgv < 1.0:
+                        r = (v - bgv) / (1.0 - bgv + 1e-6)
+                        acc[y, x] = r if r > 0.0 else 0.0
+                    else:
+                        acc[y, x] = 0.0
+        return acc
+
     @nb.njit(cache=True, parallel=True, fastmath=True, boundscheck=False)
     def _jit_popcount_density(spread: np.ndarray) -> np.ndarray:
         """Conta bit set per pixel: ritorna (H, W) float32 in [0..8]."""
@@ -134,6 +183,8 @@ if HAS_NUMBA:
         _jit_score_by_shift(resp, dx, dy, b, ba)
         spread = np.zeros((32, 32), dtype=np.uint8)
         _jit_score_bitmap(spread, dx, dy, b, np.uint8(0xFF))
+        bg = np.zeros((32, 32), dtype=np.float32)
+        _jit_score_bitmap_rescored(spread, dx, dy, b, np.uint8(0xFF), bg)
         _jit_popcount_density(spread)
 
 else:  # pragma: no cover
@@ -144,6 +195,9 @@ else:  # pragma: no cover
     def _jit_score_bitmap(spread, dx, dy, bins, bit_active):
         raise RuntimeError("numba non disponibile")
 
+    def _jit_score_bitmap_rescored(spread, dx, dy, bins, bit_active, bg):
+        raise RuntimeError("numba non disponibile")
+
     def _jit_popcount_density(spread):
         raise RuntimeError("numba non disponibile")
 
@@ -172,6 +226,26 @@ def score_bitmap(
     return _numpy_score_by_shift(resp, dx, dy, bins, None)
 
 
+def score_bitmap_rescored(
+    spread: np.ndarray, dx: np.ndarray, dy: np.ndarray, bins: np.ndarray,
+    bit_active: int, bg: np.ndarray,
+) -> np.ndarray:
+    """Score bitmap + rescore fusi in un solo pass (JIT)."""
+    if HAS_NUMBA and len(dx) > 0:
+        return _jit_score_bitmap_rescored(
+            np.ascontiguousarray(spread, dtype=np.uint8),
+            np.ascontiguousarray(dx, dtype=np.int32),
+            np.ascontiguousarray(dy, dtype=np.int32),
+            np.ascontiguousarray(bins, dtype=np.int8),
+            np.uint8(bit_active),
+            np.ascontiguousarray(bg, dtype=np.float32),
+        )
+    # Fallback: chiamate separate
+    score = score_bitmap(spread, dx, dy, bins, bit_active)
+    out = (score - bg) / (1.0 - bg + 1e-6)
+    return np.maximum(0.0, out).astype(np.float32)
+
+
 def popcount_density(spread: np.ndarray) -> np.ndarray:
     if HAS_NUMBA:
         return _jit_popcount_density(np.ascontiguousarray(spread, dtype=np.uint8))