ideal_mhd_model: share the Jacobian kernel with exact autodiff (fwd vs rev)

[krystophny]

What

Extract the half-grid Jacobian arithmetic into a shared, allocation-free kernel
ComputeHalfGridJacobian (ideal_mhd_model/jacobian_kernel.h) over flat
buffers, and use it from both the solver (IdealMhdModel::computeJacobian)
and an Enzyme forward/reverse autodiff test. One implementation, no duplication.

Why

This is the first kernel of the exact analytic+autodiff Hessian. The kernel maps
full-grid geometry to the half-grid r12, ru12, zu12, rs, zs and the Jacobian
tau. tau is nonlinear in the geometry, so its Jacobian is a building block of
the MHD force Hessian (chain rule composes the kernel Jacobians with the linear
spectral transforms to give the Hessian-vector product).

Writing it allocation-free over flat buffers is exactly the form Enzyme
differentiates -- both forward and reverse mode abort on dynamic Eigen
temporaries, and cannot dup member-struct objects. The solver keeps the kernel
plus the unchanged Jacobian-sign check.

Verification

Production is bit-for-bit unchanged: vmec_standalone MHD energy on solovev
2.548352e+00 and cth_like_fixed_bdy 5.057191e-02, before and after.

Enzyme test (ctest -R jacobian_kernel_autodiff, with
-DVMECPP_ENABLE_ENZYME=ON) differentiates the shared kernel; for
L = 0.5||outputs||^2:

reverse dL.v vs finite-diff : 1.9e-9      (exact, FD-limited)
forward dL.v vs finite-diff : 1.9e-9
forward / reverse agreement : 3e-15       (machine precision)
performance: reverse ~15 us (full 3328-elt gradient) | forward ~15 us (one direction)

Reverse returns the whole gradient per pass (~3300x more efficient for a full
scalar gradient); forward is the cheaper primitive for a single
Jacobian/Hessian-vector product.

Scope

First of the force-chain kernels. The remaining kernels (metric, B^contra,
B_cov, pressure/energy, MHD force) follow the same shared-kernel pattern; the
exact force Hessian-vector product then composes them with the linear transforms
applied analytically. Stacked on #6.