feat(euclidean): full analytic edge-DOF (cyclic) Hessian; Tier-2 Wente finding

Upgrades the cyclic Euclidean Hessian from block-FD to closed-form, satisfying
the novelty-statement §3.2 "analytic Hessians, not finite difference" claim for
the Euclidean path.

- euclidean_hessian.hpp: `euclidean_hessian_analytic` — closed-form cyclic
  Hessian from the law-of-cosines angle derivatives
    ∂α_i/∂s_i = ℓ_i²/4A,  ∂α_i/∂s_j = ½cot α_i − ℓ_j²/4A   (Σ_j = 0),
  chained to (u, λ_e) and sign-mapped to the gradient outputs (−α vertex,
  +α_opp edge). Reuses euclidean_cot_weights. Block-FD kept as cross-check.
- newton_solver.hpp: newton_euclidean cyclic path now uses the analytic Hessian.
- tests: CyclicHessian_Analytic_MatchesBlockFD_Tetrahedron — analytic == block-FD
  (1e-6), == gradient FD (1e-5), symmetric (1e-9). Existing cyclic convergence
  oracle still GREEN with the analytic Hessian routed in.

Tier-2 (Wente) finding: wente_torus02.obj is a QUAD mesh (1240 quads) and the
Java golden comes from cyclic (quad-net) uniformization; the C++ period-matrix
pipeline is triangle-based, so a faithful bit-vs-Java τ comparison needs a
quad/cyclic pipeline (Phase 9f). Deferred and documented; golden τ = ½+i√3/2.

244/244 cgal tests pass.

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

doc/reviewer/java-ignore-crossvalidation.md

@@ -151,9 +151,26 @@ cotangent Laplacian.
 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.
+little.
+
+### Tier-2 (Wente) finding (2026-05-30) — needs a quad/cyclic pipeline
+
+`wente_torus02.obj` is a **quad mesh** (1240 quads, genus 1), and the Java
+`wente_uniformization.xml` golden (uniformizing group → τ = (√2+i√6)/(2√2) =
+½ + i·√3/2, the hexagonal torus) comes from Java's **cyclic (quad) net**
+uniformization. The C++ period-matrix pipeline (`run_torus_pipeline`) is
+**triangle-based**, so a faithful bit-vs-Java comparison would require triangulating
+(which changes the discrete conformal structure → no exact match) or a
+**quad/cyclic period-matrix pipeline** — that belongs to **Phase 9f** (general
+polygon meshes), not the triangle path. → Tier 2 deferred to Phase 9f; the
+hexagonal golden τ is recorded here for when that lands.
+
+### Done instead (2026-05-30): full analytic edge-DOF Hessian
+With Tier-2 gated on a quad pipeline, the higher-value clean win was upgrading
+the cyclic Hessian from block-FD to **fully analytic** (closed-form
+`∂α_i/∂s_i = ℓ_i²/4A`, `∂α_i/∂s_j = ½cot α_i − ℓ_j²/4A`), satisfying the
+`novelty-statement.md §3.2` "analytic Hessians, not finite difference" claim for
+the Euclidean path. Verified against block-FD and gradient-FD.
 
 ### Other generators in the Java tree
 `HyperellipticCurveGenerator` (→ Phase 13), `SchottkyGenerator` (→ Phase 11a),