fix+test: Euclidean holonomy/τ end-to-end + spherical edge-DOF oracle (2026-05-29 audit)

Bundles the 2026-05-29 Java↔C++ math-correctness audit (doc/reviewer/
java-port-audit.md, 11 findings) with two follow-up fixes.

Audit code changes:
- Finding 3 (spherical_functional): edge-DOF replacement parameterization via
  spher_eff_lambda; edge gradient α_opp⁺+α_opp⁻−θ_e (drops additive −(S⁺+S⁻)/2)
- Finding 4 (spherical_hessian): always-compiled edge-DOF throw guard
- Finding 6 (period_matrix): faithful normalizeModulus (0≤Re≤½, Im≥0, |τ|≥1)
- Finding 9 (inversive_distance): degenerate-face limiting angles, no skip
- Findings 1/2 (euclidean): degenerate gradient limiting angles + Hessian guard

Euclidean holonomy/τ fix: develop the cut surface across the dual spanning tree
only (cut_graph now exposes is_dual_tree), so genus-1 cut edges yield
non-degenerate lattice generators. Previously τ came out 0 / NaN / 1e13 on the
bundled tori; now matches the analytic revolution modulus i·√(R²−r²)/r. Re-enabled
τ reporting in the Euclidean CLI; rewrote validation.md §3/§4 accordingly.

Tests (240 CGAL, 0 skipped):
- HolonomyEndToEnd ×3 — tori of revolution (4×4, hex 6×6, 8×8) vs analytic modulus
- SphericalFunctional.EdgeGradient_RegularTetClosedForm — independent closed-form
  π/3 oracle locking the Finding-3 edge formula (the path-integral FD check cannot
  detect a wrong-but-conservative gradient)

Also documents the latent spherical/hyperbolic holonomy-extraction bug (same
single-development pattern, dead code today) in research-track.md (Phase 9c/10),
and adds favour/normalisations to the codespell ignore list.

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

code/include/cut_graph.hpp

@@ -49,6 +49,13 @@ struct CutGraph {
     /// Indices of the 2g cut edges in order (size = 2g).
     std::vector<std::size_t> cut_edge_indices;
 
+    /// dual_tree_edge_flags[e.idx()] = true ↔ edge `e` is a dual-spanning-tree
+    /// edge (its dual is in T*).  Size = mesh.number_of_edges().
+    /// Crossing only these edges develops the surface onto a topological disk
+    /// (the fundamental polygon), so that the `2g` cut edges become genuine
+    /// boundary identifications carrying the holonomy generators.
+    std::vector<bool> dual_tree_edge_flags;
+
     /// Genus of the surface (0 for topological spheres and open patches).
     int genus = 0;
 
@@ -58,6 +65,14 @@ struct CutGraph {
         return static_cast<std::size_t>(e.idx()) < cut_edge_flags.size()
             && cut_edge_flags[static_cast<std::size_t>(e.idx())];
     }
+
+    /// `true` iff edge `e` is a dual-spanning-tree edge (crossable when
+    /// developing the surface onto a disk).
+    bool is_dual_tree(Edge_index e) const
+    {
+        return static_cast<std::size_t>(e.idx()) < dual_tree_edge_flags.size()
+            && dual_tree_edge_flags[static_cast<std::size_t>(e.idx())];
+    }
 };
 
 /// Compute the cut graph of `mesh` via the standard tree-cotree
@@ -145,6 +160,11 @@ inline CutGraph compute_cut_graph(const ConformalMesh& mesh)
         cg.cut_edge_indices.push_back(idx);
     }
 
+    // Expose the dual spanning tree T*: developing across only these edges
+    // unfolds the surface onto a disk, making the cut edges the boundary
+    // identifications that carry the holonomy generators.
+    cg.dual_tree_edge_flags = std::move(dual_tree_edge);
+
     return cg;
 }