Convert AnonymousStruct shadow to NTuple in batch forward rules

The forward rules for batch width > 1 asserted
`shadow_result[1]::NTuple{W, T}` but `Enzyme.autodiff(Forward, …,
BatchDuplicated{T,W}, …)` returns the batch shadow wrapped in
`Enzyme.Compiler.AnonymousStruct` — a
`NamedTuple{(:1, :2, …), NTuple{W, T}}` (see
`Enzyme/src/compiler/utils.jl:480`).

The mismatch tripped the existing `Enzyme batch forward mode (width > 1)`
testset on `main` with:

```
TypeError: in typeassert, expected Tuple{Float64, Float64},
got a value of type @NamedTuple{1::Float64, 2::Float64}
```

Wrap the shadow in `Tuple(...)` before the type-assert so the rule's
return matches the `BatchDuplicated` shadow contract that Enzyme expects
from a forward rule.  Applies to both `{false, true, W>1, …}`
(shadow-only) and `{true, true, W>1, …}` (ForwardWithPrimal) rules.

The existing testset (which was failing on `main`) now passes.  Full
local test summary on Julia 1.11 + Enzyme v0.13.147:

```
FunctionWrappersWrappers.jl |   48     48
BigFloat support            |    5      5
UnionAll return types       |    2      2
Enzyme extension            |   44     44
Mooncake extension          |   13     13
```

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

Author: ChrisRackauckas

ext/FunctionWrappersWrappersEnzymeExt.jl

@@ -49,7 +49,12 @@ function EnzymeRules.forward(
         return shadow_result[1]::T
     else
         shadow_result = Enzyme.autodiff(mode, Const(f_orig), BatchDuplicated{T, W}, args...)
-        return shadow_result[1]::NTuple{W, T}
+        # Enzyme returns the batch shadow as an `AnonymousStruct` — a
+        # `NamedTuple{(:1, :2, …), NTuple{W, T}}` (see
+        # `Enzyme.Compiler.AnonymousStruct` in `Enzyme/src/compiler/utils.jl`).
+        # Convert to a plain tuple so the rule's return matches the
+        # `BatchDuplicated` shadow contract Enzyme expects from a forward rule.
+        return Tuple(shadow_result[1])::NTuple{W, T}
     end
 end
 
@@ -73,7 +78,9 @@ function EnzymeRules.forward(
         return Duplicated(primal, shadow)
     else
         shadow_result = Enzyme.autodiff(mode, Const(f_orig), BatchDuplicated{T, W}, args...)
-        shadows = shadow_result[1]::NTuple{W, T}
+        # See the comment on the {false, true} rule — `shadow_result[1]` is a
+        # NamedTuple, not an NTuple.
+        shadows = Tuple(shadow_result[1])::NTuple{W, T}
         return BatchDuplicated(primal, shadows)
     end
 end