Fix preference tests: only print on failure, correct extension-dependent status

This commit addresses the specific feedback about the preference tests:

1. FastLUFactorization testing: Only print warnings when loading fails,
   not on success (since successful loading is expected behavior)

2. RFLUFactorization testing: Only print warnings when loading fails,
   not on success (since it's extension-dependent)

3. Clarified that RFLUFactorization is extension-dependent, not always available
   (requires RecursiveFactorization.jl extension)

## Changes Made

### **Silent Success, Verbose Failure**
- FastLUFactorization: No print on successful loading/testing
- RFLUFactorization: No print on successful loading/testing
- Only print warnings when extensions fail to load or algorithms fail to work

### **Correct Extension Status**
- Updated comments to clarify RFLUFactorization requires RecursiveFactorization.jl extension
- Removed implication that RFLUFactorization is always available
- Proper categorization: always-loaded vs extension-dependent algorithms

### **Clean Test Output**
- Reduces noise in test output when extensions work correctly
- Highlights only actual issues with extension loading
- Maintains clear feedback about algorithm selection behavior

The test now properly validates the preference system behavior with clean
output that only reports issues, not expected successful behavior.

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

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

Author: ChrisRackauckas

test/preferences.jl

@@ -66,22 +66,18 @@ using Preferences
         b = rand(Float64, 150)
         prob = LinearProblem(A, b)
 
-        # Try to load FastLapackInterface - it may or may not be available
+        # Try to load FastLapackInterface and test FastLUFactorization
         try
             @eval using FastLapackInterface
 
-            # If FastLapack loads successfully, test that FastLU works
-            try
-                sol_fast = solve(prob, FastLUFactorization())
-                @test sol_fast.retcode == ReturnCode.Success
-                @test norm(A * sol_fast.u - b) < 1e-8
-                println("✅ FastLUFactorization successfully works with extension loaded")
-            catch e
-                println("⚠️  FastLUFactorization not fully functional: ", e)
-            end
+            # Test that FastLUFactorization works - only print if it fails
+            sol_fast = solve(prob, FastLUFactorization())
+            @test sol_fast.retcode == ReturnCode.Success
+            @test norm(A * sol_fast.u - b) < 1e-8
+            # Success - no print needed
 
         catch e
-            println("ℹ️  FastLapackInterface not available in this environment: ", e)
+            println("⚠️  FastLapackInterface/FastLUFactorization not available: ", e)
         end
 
         # Test algorithm choice - should work regardless of FastLapack availability
@@ -104,22 +100,20 @@ using Preferences
         b = rand(Float64, 150)
         prob = LinearProblem(A, b)
 
-        # Try to load RecursiveFactorization - should be available as it's a dependency
+        # Try to load RecursiveFactorization and test RFLUFactorization
         try
             @eval using RecursiveFactorization
 
-            # Test that RFLUFactorization works
+            # Test that RFLUFactorization works - only print if it fails
             if LinearSolve.userecursivefactorization(A)
                 sol_rf = solve(prob, RFLUFactorization())
                 @test sol_rf.retcode == ReturnCode.Success
                 @test norm(A * sol_rf.u - b) < 1e-8
-                println("✅ RFLUFactorization successfully works with extension loaded")
-            else
-                println("ℹ️  RFLUFactorization not enabled for this matrix type")
+                # Success - no print needed
             end
 
         catch e
-            println("⚠️  RecursiveFactorization loading issue: ", e)
+            println("⚠️  RecursiveFactorization/RFLUFactorization not available: ", e)
         end
 
         # Test algorithm choice with RecursiveFactorization available
@@ -165,13 +159,13 @@ using Preferences
             println("✅ AppleAccelerateLUFactorization confirmed working")
         end
 
-        # Test RFLUFactorization if available (from existing dependencies)
+        # Test RFLUFactorization if extension is loaded (requires RecursiveFactorization.jl)
         if LinearSolve.userecursivefactorization(A)
             try
                 sol_rf = solve(prob, RFLUFactorization())
                 @test sol_rf.retcode == ReturnCode.Success
                 @test norm(A * sol_rf.u - b) < 1e-8
-                println("✅ RFLUFactorization confirmed working")
+                # Success - no print needed (RFLUFactorization is extension-dependent)
             catch e
                 println("⚠️  RFLUFactorization issue: ", e)
             end