Add fallback Base.copy method for AbstractSciMLOperator

This adds a fallback copy method for AbstractSciMLOperator that provides
safe copying behavior for operators that don't have specific copy methods
defined. This prevents issues when LinearSolve.jl tries to copy operators
in the initialization path, addressing CI failures in LinearSolve.jl PR #763.

The fallback method:
- For convertible operators: Creates a new operator from the copied concrete representation
- For non-convertible operators: Falls back to deepcopy as a last resort
- Includes appropriate warnings when using fallback behavior

This ensures all SciMLOperators have a copy method available, preventing
MethodError exceptions when copy() is called on complex operator types.

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

Co-Authored-By: Claude <[email protected]>

Author: ChrisRackauckas

src/interface.jl

@@ -460,4 +460,34 @@ function LinearAlgebra.mul!(v::AbstractArray,
     end
     mul!(v, concretize(L), u, α, β)
 end
+
+"""
+    Base.copy(L::AbstractSciMLOperator)
+
+Default fallback for copying SciMLOperators. This method provides a safe
+fallback for operators that don't have a specific copy method defined,
+avoiding the need for deepcopy in LinearSolve.jl initialization paths.
+
+For operators that can be converted to concrete matrices, this creates a new
+operator from the copied concrete representation. For operators that cannot
+be easily converted, this falls back to deepcopy as a last resort.
+"""
+function Base.copy(L::AbstractSciMLOperator)
+    # This is the fallback method - it should only be called if no specific
+    # copy method is defined for the concrete type
+    if isconvertible(L)
+        # Try to reconstruct the operator from its concrete representation
+        try
+            concrete = concretize(L)
+            return MatrixOperator(copy(concrete))
+        catch
+            @warn "Failed to copy via concrete representation, falling back to deepcopy"
+            return deepcopy(L)
+        end
+    else
+        @warn "Using deepcopy fallback for non-convertible operator in Base.copy"
+        return deepcopy(L)
+    end
+end
+
 #