docs: reframe TODO L160 won't-fix on bit-identity, not test pins (codex P2/P3)

Address the AI review on PR #517:
- P2: the prior wording claimed both drifts "exceed the tightest pins" and
  cited test_linalg_hc2_bm.py atol=1e-14 / test_methodology_wls_cr2.py
  "bit-equal 1e-14". That misstated the evidence: 6.4e-15 < 1e-14; the
  wls_cr2 regression-safety assert is atol=1e-12 (1e-14 is only a comment);
  and the 1e-14 asserts in test_linalg_hc2_bm.py are HC1 default-vs-explicit
  dispatch-equality sentinels, not the HC2/HC2-BM reuse path. Reframe on the
  real blocker — strict bit-identity (no SE may move) — and note both drifts
  sit BELOW the affected goldens' 1e-12/1e-10 tolerances, so a broad reuse
  would silently shift SEs without tripping the suite (which is exactly what
  the bit-identity bar prevents).
- P3: move "Won't-fix" out of the Priority column (back to Low) and keep the
  status in the issue text, per the TODO.md table schema.

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

Author: igerber

TODO.md

@@ -157,7 +157,7 @@ Deferred items from PR reviews that were not addressed before merge.
 |-------|----------|----|----------|
 | ImputationDiD event-study SEs recompute full conservative variance per horizon (should cache A0/A1 factorization) | `imputation.py` | #141 | Low |
 | Rust faer SVD ndarray-to-faer conversion overhead (minimal vs SVD cost) | `rust/src/linalg.rs:67` | #115 | Low |
-| **Won't-fix — not bit-identically achievable (verified 2026-06-01).** The proposed `bread_inv` reuse / "factor `(X'WX)` once, reuse across HC2/HC2-BM" cannot be done without shifting SEs past the existing goldens. The internal bread operations solve against *different* right-hand sides (`X.T` for hat-diagonals, `eye` for classical/CR2, `meat`+`temp.T` for the sandwich, `contrasts` for BM-DOF); only **same-RHS** results are bit-reusable. Measured (numpy 2.4.5): `scipy.linalg.lu_solve(lu_factor(A), B)` differs from `np.linalg.solve(A, B)` by up to 6.4e-15 (only 32/900 bit-equal — `dgesv` fuses factor+solve and rounds differently from `dgetrf`+`dgetrs`); the `inv(A) @ meat @ inv(A)` sandwich differs from the current double-`solve` by up to 1.24e-14 — both exceed the tightest pins (`test_linalg_hc2_bm.py` atol=1e-14; `test_methodology_wls_cr2.py` "bit-equal 1e-14"). `np.linalg.solve(A, eye) == np.linalg.inv(A)` IS bit-identical (and raises the same `LinAlgError`) but swapping saves nothing. The *only* genuine bit-identical redundancy is one duplicated `solve(bread, X.T)` (hat-diagonals + the DOF `H`-build) in the unweighted one-way `hc2_bm`+`return_dof` path — an O(k²n) solve dwarfed by the O(n²) `M=I−H` build and the O(G²·n²) per-coefficient DOF loop, so the achievable saving is negligible. | `linalg.py::compute_robust_vcov` | Phase 1a | Won't-fix |
+| **Won't-fix — not bit-identically achievable (verified 2026-06-01).** The proposed `bread_inv` reuse / "factor `(X'WX)` once, reuse across HC2/HC2-BM" cannot be done **bit-identically**, which is the bar for a pure perf refactor of the inference path (no SE may move at all). The internal bread operations solve against *different* right-hand sides (`X.T` for hat-diagonals, `eye` for classical/CR2, `meat`+`temp.T` for the sandwich, `contrasts` for BM-DOF); only **same-RHS** results are bit-reusable. Measured (numpy 2.4.5): `scipy.linalg.lu_solve(lu_factor(A), B)` differs from `np.linalg.solve(A, B)` by up to 6.4e-15 (only 32/900 bit-equal — `dgesv` fuses factor+solve and rounds differently from a separate `dgetrf`+`dgetrs`); the `inv(A) @ meat @ inv(A)` sandwich differs from the current double-`solve` by up to 1.24e-14. Both are **nonzero → not bit-identical** — and note both sit *below* the affected goldens' actual tolerances (the HC2/HC2-BM/CR2 asserts are atol 1e-12/1e-10, e.g. `test_methodology_wls_cr2.py::TestUnweightedRegressionStillBitEqual` at 1e-12; the atol=1e-14 checks in `test_linalg_hc2_bm.py` are HC1 default-vs-explicit *dispatch*-equality sentinels, not this path), so a broad reuse would silently shift SEs at ~1e-14 *without* tripping the suite, which is exactly what the bit-identity bar exists to prevent. `np.linalg.solve(A, eye) == np.linalg.inv(A)` IS bit-identical (and raises the same `LinAlgError`) but swapping saves nothing. The *only* genuine bit-identical redundancy is one duplicated `solve(bread, X.T)` (hat-diagonals + the DOF `H`-build) in the unweighted one-way `hc2_bm`+`return_dof` path — an O(k²n) solve dwarfed by the O(n²) `M=I−H` build and the O(G²·n²) per-coefficient DOF loop, so the achievable saving is negligible. | `linalg.py::compute_robust_vcov` | Phase 1a | Low |
 | MPD cluster+hc2_bm path computes CR2 precomputes twice — once via `solve_ols` → `_compute_cr2_bm` for vcov + per-coefficient DOF, then again via `_compute_cr2_bm_contrast_dof` from `MultiPeriodDiD.fit()` for the post-period-average contrast DOF. Both rebuild `H = X bread_inv X'`, the residual-maker `M`, and the per-cluster `A_g = (I - H_gg)^{-1/2}` matrices. O(n²k) redundant work; acceptable for typical cluster-robust DiD panel sizes (n ≤ a few thousand). Fix would plumb the contrast DOF through the existing CR2 vcov path (intrusive API change) or share the precomputes via a cached helper. | `linalg.py::_compute_cr2_bm_contrast_dof`, `estimators.py::MultiPeriodDiD.fit` | follow-up | Low |
 | Rust-backend HC2 implementation. Current Rust path only supports HC1; HC2 and CR2 Bell-McCaffrey fall through to the NumPy backend. For large-n fits this is noticeable. | `rust/src/linalg.rs` | Phase 1a | Low |
 | CR2 Bell-McCaffrey DOF uses a naive `O(n² k)` per-coefficient loop over cluster pairs. Pustejovsky-Tipton (2018) Appendix B has a scores-based formulation that avoids the full `n × n` `M` matrix. Switch when a user hits a large-`n` cluster-robust design. | `linalg.py::_compute_cr2_bm` | Phase 1a | Low |