Fix type inference issue with LinearVerbosity keyword constructor

This commit fixes a type stability issue in the `LinearVerbosity` keyword
argument constructor that was causing type inference failures in `LinearCache`
initialization.

Root Cause:
The keyword argument constructor for `LinearVerbosity` was not type-stable
because `values(final_args)...` produces different types depending on runtime
kwargs, preventing the compiler from inferring a concrete type.

Solution:
1. Added a fast path in the keyword constructor that returns early with a
   concrete type when all arguments are `nothing` (the default case)
2. Added `Base.@constprop :aggressive` to `__init` to help the compiler
   propagate the default `verbose=true` constant through the call chain

This ensures that `LinearVerbosity()` with no arguments is type-stable,
which is the common case when users rely on defaults.

Changes:
- src/verbosity.jl: Added fast path for default construction
- src/common.jl: Added @constprop :aggressive to __init function

Fixes the CI error:
```
return type LinearCache{..., LinearVerbosity{...}, ...} does not match
inferred return type LinearCache{..., _A<:LinearVerbosity, ...}
```

All tests pass with this change.

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

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

Author: ChrisRackauckas

src/common.jl

@@ -261,7 +261,7 @@ function SciMLBase.init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm, arg
     __init(prob, alg, args...; kwargs...)
 end
 
-function __init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm,
+Base.@constprop :aggressive function __init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm,
         args...;
         alias = LinearAliasSpecifier(),
         abstol = default_tol(real(eltype(prob.b))),
@@ -328,7 +328,7 @@ function __init(prob::LinearProblem, alg::SciMLLinearSolveAlgorithm,
         # @warn "Using `true` or `false` for `verbose` is being deprecated. Please use a `LinearVerbosity` type to specify verbosity settings.
         # For details see the verbosity section of the common solver options documentation page."
         init_cache_verb = verbose
-        if verbose 
+        if verbose
             verbose_spec = LinearVerbosity()
         else
             verbose_spec = LinearVerbosity(SciMLLogging.None())

src/verbosity.jl

@@ -94,6 +94,28 @@ end
 
 function LinearVerbosity(;
         error_control = nothing, performance = nothing, numerical = nothing, kwargs...)
+    # Fast path for default construction (type-stable)
+    if error_control === nothing && performance === nothing &&
+       numerical === nothing && isempty(kwargs)
+        return LinearVerbosity(
+            Silent(),
+            Silent(),
+            Silent(),
+            Silent(),
+            CustomLevel(1), # WARN_LEVEL in KrylovKit.jl
+            Silent(),
+            InfoLevel(),
+            Silent(),
+            ErrorLevel(),
+            ErrorLevel(),
+            Silent(),
+            Silent(),
+            Silent(),
+            WarnLevel(),
+            WarnLevel(),
+            WarnLevel())
+    end
+
     # Validate group arguments
     if error_control !== nothing && !(error_control isa AbstractMessageLevel)
         throw(ArgumentError("error_control must be a SciMLLogging.AbstractMessageLevel, got $(typeof(error_control))"))