Skip J reuse logic entirely for non-W-methods (IIP + OOP)

Non-W-methods (strict Rosenbrock like Rodas5P) always recompute J and W.
Bypass the reuse decision, newJW hint, and jac_reuse bookkeeping entirely
for these methods. The jac_reuse mutations (pending_dtgamma, last_step_iter)
during the forward pass interfere with Enzyme + Krylov solvers, causing
Rodas5P to lose 5th-order convergence (observed order 1.74).

IIP path: use original calc_W! without newJW hint for non-W-methods.
OOP path: early return to standard calc_tderivative + calc_W path.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>
Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ChrisRackauckas

lib/OrdinaryDiffEqDifferentiation/src/derivative_utils.jl

@@ -830,26 +830,29 @@ end
 
 function calc_rosenbrock_differentiation!(integrator, cache, dtd1, dtgamma, repeat_step)
     nlsolver = nothing
+    alg = OrdinaryDiffEqCore.unwrap_alg(integrator, true)
     # we need to skip calculating `J` and `W` when a step is repeated
     new_jac = new_W = false
     if !repeat_step
-        # For W-methods, use reuse logic; for strict Rosenbrock, always recompute
-        newJW = _rosenbrock_jac_reuse_decision(integrator, cache, dtgamma)
-        new_jac,
-            new_W = calc_W!(
-            cache.W, integrator, nlsolver, cache, dtgamma, repeat_step, newJW
-        )
-        # Record pending dtgamma only when J was freshly computed; it will be
-        # committed as last_dtgamma when the step is accepted (checked in
-        # _rosenbrock_jac_reuse_decision). This tracks the dtgamma at the
-        # last J computation for the gamma ratio heuristic.
-        jac_reuse = get_jac_reuse(cache)
-        if jac_reuse !== nothing
-            jac_reuse.last_step_iter = integrator.iter
-            if new_jac
-                jac_reuse.pending_dtgamma = _jac_reuse_value(dtgamma)
-                jac_reuse.last_u_length = length(integrator.u)
+        if isWmethod(alg)
+            # W-methods: use reuse logic to skip expensive J recomputations
+            newJW = _rosenbrock_jac_reuse_decision(integrator, cache, dtgamma)
+            new_jac, new_W = calc_W!(
+                cache.W, integrator, nlsolver, cache, dtgamma, repeat_step, newJW
+            )
+            jac_reuse = get_jac_reuse(cache)
+            if jac_reuse !== nothing
+                jac_reuse.last_step_iter = integrator.iter
+                if new_jac
+                    jac_reuse.pending_dtgamma = _jac_reuse_value(dtgamma)
+                    jac_reuse.last_u_length = length(integrator.u)
+                end
             end
+        else
+            # Strict Rosenbrock: use original calc_W! path (no reuse, no bookkeeping)
+            new_jac, new_W = calc_W!(
+                cache.W, integrator, nlsolver, cache, dtgamma, repeat_step
+            )
         end
     end
     # If the Jacobian is not updated, we won't have to update ∂/∂t either.
@@ -867,8 +870,10 @@ system matrix. Supports Jacobian reuse for W-methods via `jac_reuse` in the cach
 function calc_rosenbrock_differentiation(integrator, cache, dtgamma, repeat_step)
     jac_reuse = get_jac_reuse(cache)
 
-    # If no reuse support or repeat step, use standard path
-    if repeat_step || jac_reuse === nothing
+    alg = OrdinaryDiffEqCore.unwrap_alg(integrator, true)
+    # Non-W-methods always recompute; skip caching to avoid extra calc_J calls
+    # that can corrupt shared AD state (e.g. Enzyme + Krylov).
+    if repeat_step || jac_reuse === nothing || !isWmethod(alg)
         dT = calc_tderivative(integrator, cache)
         W = calc_W(integrator, cache, dtgamma, repeat_step)
         return dT, W