test/desauty: user-side alias break in Enzyme init closure

The desauty SCC init test's Enzyme block was @test_broken because
`Enzyme.gradient(set_runtime_activity(Reverse), Const(closure), itunables)`
silently returned zero. Root cause:

  * The closure captures `iprob` (an `SCCNonlinearProblem`).
  * `irepack(t)` builds a new `MTKParameters` via `@set! p.tunable = t`,
    which **shares the `caches` tuple** with the captured `iprob.p.caches`
    (correct semantics for SciMLStructures' lightweight repack).
  * The inner `solve!`'s SCC machinery mutates that aliased cache buffer.
  * `Const(closure_capturing_iprob)` tells Enzyme not to allocate a
    shadow for the captured state, so the derivative info carried by
    those cache writes has no shadow buffer to land in and is silently
    dropped. See EnzymeAD/Enzyme.jl#3124 for the minimal reproducer.

User-side fix (no source changes outside the test): explicitly copy the
caches tuple via `ConstructionBase.setproperties` before `remake`, so
the new `MTKParameters` carries fresh cache buffers and Enzyme's
`set_runtime_activity` reverse pass correctly produces non-zero
gradients. Verified locally: matches FiniteDiff to 8 significant
figures.

`@test_broken` → `@test`; the `use_scc = false` and `use_scc = true`
branches now both share the same test block.

Co-Authored-By: Chris Rackauckas <accounts@chrisrackauckas.com>

Author: ChrisRackauckas

test/desauty_dae_mwe.jl

@@ -4,6 +4,7 @@ using ModelingToolkit: t_nounits as t, D_nounits as D
 import SciMLStructures as SS
 import SciMLSensitivity
 import SciMLBase
+import ConstructionBase
 using SymbolicIndexingInterface
 using FiniteDiff
 using ForwardDiff
@@ -134,37 +135,40 @@ eqs = [
             # per EnzymeAD/Enzyme.jl#3117 — annotating with `Const` is the
             # fix.
             #
-            # With these annotations, the plain `NonlinearProblem` case
-            # (use_scc = false) now passes. The `SCCNonlinearProblem` case
-            # (use_scc = true) still trips a `MixedDuplicated` /
-            # `Core.SimpleVector` MethodError further down in Enzyme's
-            # runtime-activity wrapping for the MTK-System /
-            # NonlinearSolution types involved in SCC sub-problem
-            # assembly — tracked in SciMLSensitivity.jl#1359. When that
-            # lifts, flipping `@test_broken` → `@test` in the `use_scc`
-            # branch is the only change needed here.
+            # For `use_scc = true` the closure must additionally **break
+            # the alias** between the captured `iprob.p.caches` and the
+            # `MTKParameters` constructed by `irepack`: in MTK SCC init,
+            # `SciMLStructures.replace(Tunable, p, t)` builds the new
+            # `MTKParameters` via `@set! p.tunable = t`, which shares
+            # `caches` with the captured template. When the inner
+            # `solve!`'s cache writes flow into that shared buffer,
+            # `Enzyme.gradient(set_runtime_activity(Reverse), Const(loss))`
+            # has no shadow for the captured mutable state and silently
+            # drops the derivative info (see EnzymeAD/Enzyme.jl#3124).
+            # Copying `caches` via `ConstructionBase.setproperties` before
+            # `remake` decouples the buffers and lets Enzyme produce the
+            # correct gradient.
             enzyme_init_loss = let iprob = iprob, irepack = irepack
                 p -> begin
-                    iprob2 = remake(iprob, p = irepack(p))
+                    p_initial = irepack(p)
+                    fresh_caches = ntuple(
+                        i -> copy(p_initial.caches[i]),
+                        length(p_initial.caches),
+                    )
+                    p_fresh = ConstructionBase.setproperties(
+                        p_initial; caches = fresh_caches,
+                    )
+                    iprob2 = remake(iprob, p = p_fresh)
                     sol = solve(iprob2, NewtonRaphson())
                     sum(sol.u)
                 end
             end
-            if use_scc
-                @test_broken begin
-                    igs = Enzyme.gradient(
-                        Enzyme.set_runtime_activity(Enzyme.Reverse),
-                        Enzyme.Const(enzyme_init_loss), itunables,
-                    )
-                    !iszero(sum(igs))
-                end
-            else
-                igs = Enzyme.gradient(
-                    Enzyme.set_runtime_activity(Enzyme.Reverse),
-                    Enzyme.Const(enzyme_init_loss), itunables,
-                )
-                @test !iszero(sum(igs))
-            end
+            igs = Enzyme.gradient(
+                Enzyme.set_runtime_activity(Enzyme.Reverse),
+                Enzyme.Const(enzyme_init_loss), itunables,
+            )
+            @test !iszero(sum(igs))
+            @test isapprox(igs[1], fd_init_grad, rtol = 0.05)
         end
 
         @testset "Mooncake through init" begin