Revert all changes that deleted tests or disabled doc example runs

Restores:
- @example blocks in ad.md and modelingtoolkit.md (were converted to
  plain julia fences)
- Original forward_diff.jl test without try_solve error swallowing
- ModelingToolkit, Zygote, Optimization deps in test/Project.toml
- Full MTK DAE test (unconditional, no identify_package check)
- Removes the split gpu_ode_modelingtoolkit_dae_mtk.jl file

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

Author: ChrisRackauckas

docs/src/examples/ad.md

@@ -4,7 +4,7 @@
 and thus can be thrown into deep learning training loops. The following is an example
 of this use:
 
-```julia
+```@example ad
 using OrdinaryDiffEq, SciMLSensitivity, Flux, DiffEqGPU, CUDA
 
 CUDA.allowscalar(false)
@@ -48,7 +48,7 @@ end
 Forward-mode automatic differentiation works as well, as demonstrated by its capability
 to recompile for Dual number arithmetic:
 
-```julia
+```@example ad
 using OrdinaryDiffEq, DiffEqGPU, ForwardDiff, Test
 
 function lorenz(du, u, p, t)

docs/src/tutorials/modelingtoolkit.md

@@ -72,7 +72,7 @@ u0, p = sym_setter(prob, SVector{3}(rand(Float32, 3)))
 Notice it takes in the vector of values for `[σ, ρ, β]` and spits out the new `u0, p`. So
 we can build and solve an MTK generated ODE on the GPU using the following:
 
-```julia
+```@example mtk
 using DiffEqGPU, CUDA
 function prob_func2(prob, i, repeat)
     u0, p = sym_setter(prob, SVector{3}(rand(Float32, 3)))
@@ -86,6 +86,6 @@ sol = solve(monteprob, GPUTsit5(), EnsembleGPUKernel(CUDA.CUDABackend()),
 
 We can then using symbolic indexing on the result to inspect it:
 
-```julia
+```@example mtk
 [sol.u[i][y] for i in 1:length(sol.u)]
 ```

test/Project.toml

@@ -10,7 +10,10 @@ GPUArraysCore = "46192b85-c4d5-4398-a991-12ede77f4527"
 JLArrays = "27aeb0d3-9eb9-45fb-866b-73c2ecf80fcb"
 KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c"
 LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+ModelingToolkit = "961ee093-0014-501f-94e3-6117800e7a78"
 OpenCL = "08131aa3-fb12-5dee-8b74-c09406e224a2"
+Optimization = "7f7a1694-90dd-40f0-9382-eb1efda571ba"
+OptimizationOptimisers = "42dfb2eb-d2b4-4451-abcd-913932933ac1"
 OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
@@ -22,6 +25,7 @@ Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
 StochasticDiffEq = "789caeaf-c7a9-5a7d-9973-96adeb23e2a0"
 TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
+Zygote = "e88e6eb3-aa80-5325-afca-941959d7151f"
 pocl_jll = "627d6b7a-bbe6-5189-83e7-98cc0a5aeadd"
 
 [compat]
@@ -34,12 +38,16 @@ ForwardDiff = "0.10.38, 1"
 GPUArraysCore = "0.2"
 JLArrays = "0.1, 0.2, 0.3"
 KernelAbstractions = "0.9"
+ModelingToolkit = "11.17.0"
 OpenCL = "0.9, 0.10"
+Optimization = "4, 5"
+OptimizationOptimisers = "0.3"
 OrdinaryDiffEq = "6"
 SafeTestsets = "0.1"
 SciMLBase = "2.144"
 StaticArrays = "1.9"
 Statistics = "1"
 StochasticDiffEq = "6"
 TOML = "1"
+Zygote = "0.7.3"
 pocl_jll = "6, 7"

test/gpu_kernel_de/forward_diff.jl

@@ -1,4 +1,4 @@
-using DiffEqGPU, OrdinaryDiffEq, StaticArrays, LinearAlgebra, Test
+using DiffEqGPU, OrdinaryDiffEq, StaticArrays, LinearAlgebra
 include("../utils.jl")
 
 using ForwardDiff
@@ -32,45 +32,18 @@ prob = ODEProblem{false}(lorenz, u0, tspan, p)
 prob_func = (prob, i, repeat) -> remake(prob, p = p)
 monteprob = EnsembleProblem(prob, prob_func = prob_func, safetycopy = false)
 
-# NOTE: On some CUDA GPUs (e.g. V100), SVector{3, ForwardDiff.Dual{Nothing, Float32, 6}}
-# triggers a misaligned address error (CUDA error code 716) due to the 84-byte element size
-# not satisfying GPU memory alignment requirements. This is a CUDA.jl issue, not DiffEqGPU.
-# Test that the solve either succeeds or fails with the known alignment error.
-function try_solve(monteprob, alg, backend; kwargs...)
-    try
-        sol = solve(monteprob, alg, EnsembleGPUKernel(backend, 0.0); kwargs...)
-        return sol
-    catch e
-        if occursin("misaligned address", string(e))
-            return nothing  # Known CUDA alignment issue
-        else
-            rethrow(e)
-        end
-    end
-end
-
 for alg in (
         GPUTsit5(), GPUVern7(), GPUVern9(), GPURosenbrock23(autodiff = false),
         GPURodas4(autodiff = false), GPURodas5P(autodiff = false),
         GPUKvaerno3(autodiff = false), GPUKvaerno5(autodiff = false),
     )
     @info alg
-    sol = try_solve(
-        monteprob, alg, backend,
+    sol = solve(
+        monteprob, alg, EnsembleGPUKernel(backend, 0.0),
         trajectories = 2, save_everystep = false, adaptive = false, dt = 0.01f0
     )
-    if sol !== nothing
-        @test length(sol) == 2
-    else
-        @test_broken false  # Known CUDA alignment issue with ForwardDiff Duals
-    end
-    asol = try_solve(
-        monteprob, alg, backend,
+    asol = solve(
+        monteprob, alg, EnsembleGPUKernel(backend, 0.0),
         trajectories = 2, adaptive = true, dt = 0.01f0
     )
-    if asol !== nothing
-        @test length(asol) == 2
-    else
-        @test_broken false  # Known CUDA alignment issue with ForwardDiff Duals
-    end
 end

test/gpu_kernel_de/stiff_ode/gpu_ode_modelingtoolkit_dae.jl

@@ -1,5 +1,6 @@
 using DiffEqGPU, StaticArrays, SciMLBase, LinearAlgebra, Test
-using OrdinaryDiffEq
+using ModelingToolkit, OrdinaryDiffEq
+using ModelingToolkit: t_nounits as t, D_nounits as D
 using KernelAbstractions: CPU
 
 const GROUP = get(ENV, "GROUP", "CUDA")
@@ -108,11 +109,52 @@ end
 # Test 2: ModelingToolkit cartesian pendulum DAE with initialization
 # ============================================================================
 
-# ModelingToolkit is an optional test dependency — skip this test if not available.
-# This avoids compat conflicts in the alldeps minimum-version resolution test.
-# The MTK test is in a separate file because macros need to be available at parse time.
-if Base.identify_package("ModelingToolkit") !== nothing
-    include("gpu_ode_modelingtoolkit_dae_mtk.jl")
-else
-    @info "ModelingToolkit not available, skipping MTK DAE test"
+# NOTE: This test is currently broken because ModelingToolkit problems with initialization
+# data contain MTKParameters which use Vector types that cannot be stored inline in CuArrays.
+# This is a known limitation: GPU kernels require element types that are allocated inline.
+# See: https://github.com/SciML/DiffEqGPU.jl/issues/XXX
+# Once MTK supports GPU-compatible parameter storage, this test can be re-enabled.
+@testset "MTK Pendulum DAE with initialization" begin
+    @parameters g = 9.81 L = 1.0
+    @variables px(t) py(t) [state_priority = 10] pλ(t)
+
+    eqs = [
+        D(D(px)) ~ pλ * px / L
+        D(D(py)) ~ pλ * py / L - g
+        px^2 + py^2 ~ L^2
+    ]
+
+    @mtkcompile pendulum = ODESystem(eqs, t, [px, py, pλ], [g, L])
+
+    mtk_prob = ODEProblem(
+        pendulum, [py => 0.99], (0.0, 1.0),
+        guesses = [pλ => 0.0, px => 0.1, D(px) => 0.0, D(py) => 0.0]
+    )
+
+    # Verify it has initialization data and a mass matrix
+    @test SciMLBase.has_initialization_data(mtk_prob.f)
+    @test mtk_prob.f.mass_matrix !== LinearAlgebra.I
+
+    # Reference solution with OrdinaryDiffEq
+    ref_sol = solve(mtk_prob, Rodas5P())
+    @test ref_sol.retcode == SciMLBase.ReturnCode.Success
+
+    # GPU ensemble solve - currently broken due to MTKParameters containing non-inline types
+    # Skip actual GPU solve test until MTK supports GPU-compatible parameters
+    if backend isa CPU
+        monteprob_mtk = EnsembleProblem(mtk_prob, safetycopy = false)
+        sol_mtk = solve(
+            monteprob_mtk, GPURodas5P(), EnsembleGPUKernel(backend),
+            trajectories = 2,
+            dt = 0.01,
+            adaptive = false
+        )
+        @test length(sol_mtk.u) == 2
+        @test !any(isnan, sol_mtk.u[1][end])
+
+        # GPU solution should be close to reference (fixed step so moderate tolerance)
+        @test norm(sol_mtk.u[1][end] - ref_sol.u[end]) < 1.0
+    else
+        @test_broken false # MTK DAE with initialization not yet supported on GPU
+    end
 end