feat(phase3f+3g): analytical Hessians + PI consolidation

Phase 3g — constants.hpp:
  - Introduce conformallab::PI and TWO_PI in a single constants.hpp
  - Remove scattered local PI/pi definitions from hyper_ideal_geometry.hpp,
    hyper_ideal_utility.hpp, euclidean_functional.hpp, mesh_builder.hpp,
    spherical_geometry.hpp (backward-compatible PI_SPHER alias kept)

Phase 3f — Euclidean Hessian (euclidean_hessian.hpp):
  - Cotangent-Laplace operator (Pinkall–Polthier 1993)
  - euclidean_cot_weights() helper + euclidean_hessian() + hessian_check_euclidean()
  - Correct Pinkall–Polthier 1/2 normalization factor
  - 8 tests: cot weights, symmetry, null-space (H·1=0), PSD, FD × 4 meshes

Phase 3f — Spherical Hessian (spherical_hessian.hpp):
  - Derives ∂α_i/∂u_j directly from the spherical law of cosines:
      ∂α1/∂l_opp  = sin(l_opp) / [sin(l_a)·sin(l_b)·sin(α1)]
      ∂α1/∂l_adj  = [cot(l_adj)·cos(α1) − cot(l_other)] / sin(α1)
    then chains with ∂l/∂λ = tan(l/2)
  - spherical_cot_weights() kept as a standalone helper (tested separately)
  - 8 tests: cot weights, symmetry, correct null-space & sign-convention
    (H·1 ≠ 0; H is NSD at equilibrium), FD × 3 meshes

All 62 cgal tests pass (3 skipped as before).

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

code/include/hyper_ideal_utility.hpp

@@ -4,6 +4,7 @@
 // Ported from de.varylab.discreteconformal.functional.HyperIdealUtility (Java).
 
 #include "clausen.hpp"
+#include "constants.hpp"
 
 #include <Eigen/Dense>
 #include <cmath>
@@ -16,10 +17,10 @@ namespace conformallab {
 // Corresponds to Java HyperIdealUtility.calculateTetrahedronVolume().
 inline double calculateTetrahedronVolume(double A, double B, double C,
                                          double D, double E, double F) {
-    constexpr double pi = 3.14159265358979323846264338328;
+    // PI from constants.hpp (conformallab::PI)
 
     // Degenerate if any angle equals pi.
-    if (A == pi || B == pi || C == pi || D == pi || E == pi || F == pi)
+    if (A == PI || B == PI || C == PI || D == PI || E == PI || F == PI)
         return 0.0;
 
     const double sA = std::sin(A), sB = std::sin(B), sC = std::sin(C);
@@ -81,26 +82,26 @@ inline double calculateTetrahedronVolumeWithIdealVertexAtGamma(
     double gamma1, double gamma2, double gamma3,
     double alpha23, double alpha31, double alpha12)
 {
-    constexpr double pi = 3.14159265358979323846264338328;
+    // PI from constants.hpp (conformallab::PI)
     auto L = [](double x) { return Lobachevsky(x); };
 
     double result = L(gamma1) + L(gamma2) + L(gamma3);
 
-    result += L((pi + alpha31 - alpha12 - gamma1) / 2.0);
-    result += L((pi + alpha12 - alpha23 - gamma2) / 2.0);
-    result += L((pi + alpha23 - alpha31 - gamma3) / 2.0);
+    result += L((PI + alpha31 - alpha12 - gamma1) / 2.0);
+    result += L((PI + alpha12 - alpha23 - gamma2) / 2.0);
+    result += L((PI + alpha23 - alpha31 - gamma3) / 2.0);
 
-    result += L((pi - alpha31 + alpha12 - gamma1) / 2.0);
-    result += L((pi - alpha12 + alpha23 - gamma2) / 2.0);
-    result += L((pi - alpha23 + alpha31 - gamma3) / 2.0);
+    result += L((PI - alpha31 + alpha12 - gamma1) / 2.0);
+    result += L((PI - alpha12 + alpha23 - gamma2) / 2.0);
+    result += L((PI - alpha23 + alpha31 - gamma3) / 2.0);
 
-    result += L((pi + alpha31 + alpha12 - gamma1) / 2.0);
-    result += L((pi + alpha12 + alpha23 - gamma2) / 2.0);
-    result += L((pi + alpha23 + alpha31 - gamma3) / 2.0);
+    result += L((PI + alpha31 + alpha12 - gamma1) / 2.0);
+    result += L((PI + alpha12 + alpha23 - gamma2) / 2.0);
+    result += L((PI + alpha23 + alpha31 - gamma3) / 2.0);
 
-    result += L((pi - alpha31 - alpha12 - gamma1) / 2.0);
-    result += L((pi - alpha12 - alpha23 - gamma2) / 2.0);
-    result += L((pi - alpha23 - alpha31 - gamma3) / 2.0);
+    result += L((PI - alpha31 - alpha12 - gamma1) / 2.0);
+    result += L((PI - alpha12 - alpha23 - gamma2) / 2.0);
+    result += L((PI - alpha23 - alpha31 - gamma3) / 2.0);
 
     return result / 2.0;
 }