perf(inv-dist): B1 port — block-FD Hessian for newton_inversive_distance

The Inversive-Distance solver built its Hessian inline by full finite
differences: n perturbations × a full O(F) gradient eval = O(n·F) per Newton
iteration (quadratic in mesh size), with no fast path at all (api-performance
audit B1, second half).

Port the per-face block-FD scheme already used by HyperIdeal (Phase 9b):
the gradient decomposes by face (G_v = Θ_v − Σ_{f∋v} α_v, and each face's
angles depend only on its 3 vertex DOFs), so the Hessian decomposes into
per-face 3×3 blocks.  Cost drops to O(F) face evaluations, a ≈ n/6 speed-up.

- inversive_distance_functional.hpp: add the pure 3→3 kernel
  inversive_distance_face_grad_contribs (returns the per-face contribution
  −α to G; mirrors the gradient's face-skip on ℓ²≤0 exactly).
- inversive_distance_hessian.hpp (new): full-FD baseline + block-FD + sym
  variants, mirroring hyper_ideal_hessian.hpp.
- newton_solver.hpp: drop the inline full-FD lambda; call
  inversive_distance_hessian_block_fd_sym.
- test: InversiveDistance_BlockFDHessianMatchesFullFD cross-validates the
  two Hessians entry-wise on a perturbed (off-equilibrium) config.

291/291 CGAL tests pass; all Inversive-Distance convergence tests unchanged.

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

code/include/newton_solver.hpp

@@ -36,6 +36,7 @@
 #include "hyper_ideal_hessian.hpp"
 #include "cp_euclidean_functional.hpp"
 #include "inversive_distance_functional.hpp"
+#include "inversive_distance_hessian.hpp"
 #include <Eigen/SparseCholesky>
 #include <Eigen/SparseQR>
 #include <Eigen/OrderingMethods>
@@ -546,10 +547,11 @@ inline NewtonResult newton_cp_euclidean(
 /// domain where every triangle satisfies the inequalities.  Luo's 1-form is
 /// closed there, so the path-integral energy is well-defined.
 ///
-/// MVP implementation: the Hessian is computed by **finite differences** of
-/// the analytic gradient (same pattern as the Phase 4a HyperIdeal solver).
-/// An analytic Hessian via Glickenstein 2011 eq. (4.6) is tracked in
-/// `doc/roadmap/research-track.md` as Phase 9a.2-analytic.
+/// The Hessian is computed by **per-face block finite differences**
+/// (`inversive_distance_hessian_block_fd_sym`, same pattern as the HyperIdeal
+/// solver after Phase 9b) — O(F) face evaluations instead of the O(n·F) of the
+/// full-FD baseline.  An analytic Hessian via Glickenstein 2011 eq. (4.6) is
+/// tracked in `doc/roadmap/research-track.md` as Phase 9a.2-analytic.
 ///
 /// \param mesh      Input triangle mesh.
 /// \param x0        Initial DOF vector (length = number of free vertices).
@@ -580,37 +582,6 @@ inline NewtonResult newton_inversive_distance(
     res.iterations     = 0;
     res.grad_inf_norm  = 0.0;
 
-    // Local FD Hessian builder — n × (cost of gradient eval).
-    auto build_hessian = [&](const std::vector<double>& xc) -> Eigen::SparseMatrix<double> {
-        std::vector<Eigen::Triplet<double>> trips;
-        trips.reserve(static_cast<std::size_t>(n) * 16);   // sparse heuristic
-
-        std::vector<double> xp = xc, xm = xc;
-        for (int j = 0; j < n; ++j) {
-            const std::size_t sj = static_cast<std::size_t>(j);
-            xp[sj] = xc[sj] + hess_eps;
-            xm[sj] = xc[sj] - hess_eps;
-
-            auto Gp = inversive_distance_gradient(mesh, xp, m);
-            auto Gm = inversive_distance_gradient(mesh, xm, m);
-
-            xp[sj] = xm[sj] = xc[sj];   // restore
-
-            for (int i = 0; i < n; ++i) {
-                double val = (Gp[static_cast<std::size_t>(i)]
-                            - Gm[static_cast<std::size_t>(i)])
-                             / (2.0 * hess_eps);
-                if (std::abs(val) > 1e-15)
-                    trips.emplace_back(i, j, val);
-            }
-        }
-        Eigen::SparseMatrix<double> H(n, n);
-        H.setFromTriplets(trips.begin(), trips.end());
-        // Symmetrise — FD rounding may introduce tiny asymmetries.
-        Eigen::SparseMatrix<double> Ht = H.transpose();
-        return (H + Ht) * 0.5;
-    };
-
     for (int iter = 0; iter < max_iter; ++iter) {
         auto G_std = inversive_distance_gradient(mesh, x, m);
         Eigen::Map<const Eigen::VectorXd> G(G_std.data(), n);
@@ -624,7 +595,8 @@ inline NewtonResult newton_inversive_distance(
             return res;
         }
 
-        auto H = build_hessian(x);
+        // Hessian (block-FD, ~n/6× faster than full-FD) + solve H·Δx = −G.
+        auto H = inversive_distance_hessian_block_fd_sym(mesh, x, m, hess_eps);
         bool ok = false;
         Eigen::VectorXd dx = detail::solve_with_fallback(H, -G, ok);
         if (!ok) break;