Fix recursivefill! failure with immutable StaticArrays (issue #461)

This commit fixes a bug where `recursivefill!` would fail when called on
a `VectorOfArray` containing immutable `StaticArray` types like `SVector`.

## Problem
The `Base.fill!` method for `AbstractVectorOfArray` attempted to call
`fill!` on each element array, which fails for immutable arrays that don't
support in-place modification via `setindex!`.

## Solution
Modified `Base.fill!` to check if each element is mutable before attempting
to fill it. For immutable arrays, we now create a new filled array using
`StaticArraysCore.similar_type` and assign it, following the same pattern
used in the existing `copyto!` implementation.

## Changes
- Updated `Base.fill!` in `src/vector_of_array.jl` to handle both mutable
  and immutable arrays correctly
- Added comprehensive tests in `test/utils_test.jl` to cover:
  - `VectorOfArray` with only immutable `SVector`s
  - `VectorOfArray` with mixed immutable and mutable `StaticArray`s
  - Both `recursivefill!` and `fill!` methods

All existing tests continue to pass.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: ChrisRackauckas

src/vector_of_array.jl

@@ -826,7 +826,12 @@ end
 function Base.fill!(VA::AbstractVectorOfArray, x)
     for i in 1:length(VA.u)
         if VA[:, i] isa AbstractArray
-            fill!(VA[:, i], x)
+            if ArrayInterface.ismutable(VA.u[i]) || VA.u[i] isa AbstractVectorOfArray
+                fill!(VA[:, i], x)
+            else
+                # For immutable arrays like SVector, create a new filled array
+                VA.u[i] = fill(x, StaticArraysCore.similar_type(VA.u[i]))
+            end
         else
             VA[:, i] = x
         end

test/utils_test.jl

@@ -139,6 +139,35 @@ end
     @test u1.u[2] isa SVector
 end
 
+# Test recursivefill! with immutable StaticArrays (issue #461)
+@testset "recursivefill! with immutable StaticArrays (issue #461)" begin
+    # Test with only immutable SVectors
+    x = VectorOfArray([SVector{2}(ones(2)), SVector{2}(ones(2))])
+    recursivefill!(x, 0.0)
+    @test all(x.u[i] == SVector{2}(zeros(2)) for i in 1:2)
+    @test all(x.u[i] isa SVector for i in 1:2)
+
+    # Test with mixed immutable and mutable StaticArrays
+    x = VectorOfArray([SVector{2}(ones(2)), MVector{2}(ones(2))])
+    recursivefill!(x, 0.0)
+    @test all(x.u[i] == [0.0, 0.0] for i in 1:2)
+    @test x.u[1] isa SVector
+    @test x.u[2] isa MVector
+
+    # Test fill! on VectorOfArray with immutable SVectors
+    x = VectorOfArray([SVector{2}(ones(2)), SVector{2}(ones(2))])
+    fill!(x, 0.0)
+    @test all(x.u[i] == SVector{2}(zeros(2)) for i in 1:2)
+    @test all(x.u[i] isa SVector for i in 1:2)
+
+    # Test fill! on VectorOfArray with mixed types
+    x = VectorOfArray([SVector{2}(ones(2)), MVector{2}(ones(2))])
+    fill!(x, 0.0)
+    @test all(x.u[i] == [0.0, 0.0] for i in 1:2)
+    @test x.u[1] isa SVector
+    @test x.u[2] isa MVector
+end
+
 import KernelAbstractions: get_backend
 @testset "KernelAbstractions" begin
     v = VectorOfArray([randn(2) for i in 1:10])