feat(euclidean): block-FD edge-DOF Hessian → cyclic Newton + Java convergence oracle

Implements the edge-DOF (cyclic) Euclidean Hessian, unblocking the full cyclic
Newton solve, and enables the Java EuclideanCyclicConvergenceTest cross-validation.

- euclidean_hessian.hpp: `euclidean_hessian_block_fd` / `_sym` — per-face 6×6
  block FD over (u1,u2,u3,λ12,λ23,λ31), mirroring hyper_ideal_hessian_block_fd.
  Per-face outputs carry the gradient signs (−α vertex, +α_opp edge), so the
  result equals ∂G/∂x by construction (locality lemma). Analytic vertex-only
  cotangent Hessian unchanged (still used for vertex-only layouts).
- newton_solver.hpp: newton_euclidean routes cyclic layouts (edge DOFs present)
  through the block-FD Hessian; vertex-only path unchanged.
- tests:
  * CyclicCircularEdge_CatHead_JavaXVal (now GREEN) — prescribe φ=π−0.1 on one
    interior edge, solve, assert realised α_opp+α_opp = π−0.1 @1e-9.
  * CyclicCircularEdge_PhiEntersGradient_CatHead — solver-free φ-wiring check.
  * CyclicHessian_BlockFD_MatchesGradientFD_Tetrahedron — Hessian correctness.

243/243 cgal tests pass; vertex-only Euclidean Newton unaffected.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

doc/reviewer/java-ignore-crossvalidation.md

@@ -121,33 +121,39 @@ Assertion strategy: because the values are symmetric per DOF-class, assert
    XML reader; strongest deterministic pipeline oracle that maps to landed C++).
 4. **Tier 3 — Lawson generator** (only after Tiers 1–2).
 
-### Build-verification finding (2026-05-29) — Tier 1 cyclic is blocked
+### Build-verification finding (2026-05-29) → resolved (2026-05-30)
 
 Attempting the Tier-1 `EuclideanCyclicConvergenceTest` port **build-verified** a
-blocker: `newton_euclidean` calls `euclidean_hessian`, which throws
-*"edge DOFs are not supported (only the vertex-block cotangent Laplacian is
-implemented)"*. The cyclic functional needs **vertex + edge** DOFs, so the full
-Newton solve is **not yet possible** in C++ — the *gradient* supports edge DOFs,
-the *analytic Hessian* does not. (This is also why PR #27 cross-validated only
-the cyclic *evaluation*, never a solve.)
+blocker first: `newton_euclidean` → `euclidean_hessian` threw *"edge DOFs are
+not supported"*. The cyclic functional needs **vertex + edge** DOFs (the
+*gradient* supported them; the *analytic cotangent Hessian* did not). That is
+why PR #27 cross-validated only the cyclic *evaluation*, never a solve.
 
-**Landed in this PR instead** (`test_euclidean_functional.cpp`):
-- ✅ `CyclicCircularEdge_PhiEntersGradient_CatHead` (**GREEN**) — solver-free
-  cross-validation that the circular-edge φ target enters the cyclic gradient
-  exactly (`ΔG_e = −Δφ_e` at 1e-12, no other component moves). This is the
-  evaluation-level prerequisite of the convergence oracle.
-- ⏸️ `DISABLED_CyclicCircularEdge_CatHead_JavaXVal` — the full Java convergence
-  assertion (`α_opp+α_opp = π−0.1`), kept in-code with the golden semantics; it
-  auto-activates (drop `DISABLED_`) once the edge-DOF Hessian lands.
+**Resolved (2026-05-30):** implemented a **block-FD edge-DOF Euclidean Hessian**
+(`euclidean_hessian_block_fd` / `_sym` in `euclidean_hessian.hpp`, mirroring
+`hyper_ideal_hessian_block_fd`); `newton_euclidean` now routes cyclic layouts
+(edge DOFs present) through it, vertex-only layouts still use the analytic
+cotangent Laplacian.
 
-**New prerequisite for Tier-1 cyclic:** an **edge-DOF Euclidean Hessian** (the
-cyclic Hessian over vertex + edge variables, cf. Java `getNonZeroPattern`). Spherical
-convergence (Tier-1 #2) turned out to be **already covered** by
-`test_newton_solver` (`Spherical_ConvergesFromPerturbation` et al. on the
-spherical tetrahedron), and `make_octahedron_face()` is a single face, not a
-closed octahedron — so Tier-1 #2 adds little. → the next genuinely-new
-cross-validation target is **Tier 2 (Wente uniformization XML)** or implementing
-the edge-DOF Hessian to unblock the cyclic convergence oracle.
+**Landed (`test_euclidean_functional.cpp`, all GREEN, 243/243 cgal tests pass):**
+- ✅ `CyclicCircularEdge_PhiEntersGradient_CatHead` — solver-free check that the
+  circular-edge φ enters the gradient exactly (`ΔG_e = −Δφ_e` @1e-12).
+- ✅ `CyclicCircularEdge_CatHead_JavaXVal` — **the full Java convergence
+  oracle**: prescribe φ = π−0.1 on one interior ("circular") edge of cathead,
+  solve the cyclic Newton, assert the realised `α_opp+α_opp = π−0.1` @1e-9.
+- ✅ `CyclicHessian_BlockFD_MatchesGradientFD_Tetrahedron` — the block-FD edge-DOF
+  Hessian matches the column-wise gradient FD on the full cyclic layout.
+
+> DOF note: only the **single** circular edge gets an edge DOF (as in Java's
+> one `circularHoleEdge`). Giving *every* edge a DOF makes λ_e redundant with
+> u_i+u_j (a V-dim null space) and stalls Newton.
+
+Spherical convergence (Tier-1 #2) was found **already covered** by
+`test_newton_solver` (`Spherical_ConvergesFromPerturbation` et al.), and
+`make_octahedron_face()` is a single face, not a closed octahedron — so it adds
+little. → next genuinely-new target: **Tier 2 (Wente uniformization XML)**. A
+full *analytic* edge-DOF Hessian (vs the current block-FD) remains a future
+optimisation.
 
 ### Other generators in the Java tree
 `HyperellipticCurveGenerator` (→ Phase 13), `SchottkyGenerator` (→ Phase 11a),