Simplify factorization documentation

Author: Sébastien Loisel

CLAUDE.md

@@ -91,17 +91,11 @@ Factorization uses MUMPS (MUltifrontal Massively Parallel Solver) with distribut
 - Created by `lu(A)` for general matrices or `ldlt(A)` for symmetric matrices
 - Stores COO arrays (irn_loc, jcn_loc, a_loc) to prevent GC while MUMPS holds pointers
 
-**Automatic cleanup:** Factorization objects are automatically cleaned up when garbage collected.
-The cleanup is synchronized across MPI ranks when the next factorization is created. Example:
-
 ```julia
 F = lu(A)
 x = F \ b
-# F is automatically cleaned up when GC'd and next factorization is created
 ```
 
-Manual `finalize!(F)` is still available for explicit control (must be called on all ranks together).
-
 ### Local Constructors
 
 For efficient construction when data is already distributed:

README.md

@@ -63,7 +63,6 @@ A_sym = A + transpose(A) + 10I  # Make symmetric positive definite
 A_sym_dist = SparseMatrixMPI{Float64}(A_sym)
 F = ldlt(A_sym_dist)  # LDLT factorization
 x_sol = solve(F, y)   # Solve A_sym * x_sol = y
-# F is automatically cleaned up when garbage collected
 ```
 
 ## Running with MPI

docs/src/api.md

@@ -428,15 +428,6 @@ solve
 solve!
 ```
 
-### Manual Cleanup (Optional)
-
-Factorization objects are automatically cleaned up when garbage collected.
-For explicit control, `finalize!` can be called manually (must be called on all ranks together).
-
-```@docs
-finalize!
-```
-
 ### Usage Examples
 
 ```julia
@@ -459,14 +450,10 @@ x = solve(F, b)
 # Or use backslash
 x = F \ b
 
-# F is automatically cleaned up when garbage collected
-# (or call finalize!(F) for immediate cleanup on all ranks)
-
 # For non-symmetric matrices, use LU
 A_nonsym = SparseMatrixMPI{Float64}(sprand(1000, 1000, 0.01) + 10I)
 F_lu = lu(A_nonsym)
 x = F_lu \ b
-# F_lu is automatically cleaned up when garbage collected
 ```
 
 ### Direct Solve Syntax
@@ -484,8 +471,6 @@ x = transpose(b) / A           # solve x*A = transpose(b)
 x = transpose(b) / transpose(A)  # solve x*transpose(A) = transpose(b)
 ```
 
-Note: Factorizations are automatically cleaned up when garbage collected. Cleanup is synchronized across MPI ranks when the next factorization is created.
-
 ## Cache Management
 
 ```@docs

src/mumps_factorization.jl

@@ -48,10 +48,6 @@ const _destroy_list_lock = ReentrantLock()
     MUMPSFactorizationMPI{T}
 
 Distributed MUMPS factorization result. Can be reused for multiple solves.
-
-Factorization objects are automatically cleaned up when garbage collected,
-with synchronized finalization across MPI ranks. Manual `finalize!(F)` is
-still available for explicit control (must be called on all ranks together).
 """
 mutable struct MUMPSFactorizationMPI{T}
     id::Int  # Unique ID for finalization tracking
@@ -282,7 +278,6 @@ end
 
 Compute LU factorization of a distributed sparse matrix using MUMPS.
 Returns a `MUMPSFactorizationMPI` for use with `\\` or `solve`.
-Factorization is automatically cleaned up when garbage collected.
 """
 function LinearAlgebra.lu(A::SparseMatrixMPI{T}) where T
     return _create_mumps_factorization(A, false)
@@ -294,7 +289,6 @@ end
 Compute LDLT factorization of a distributed symmetric sparse matrix using MUMPS.
 The matrix must be symmetric; only the lower triangular part is used.
 Returns a `MUMPSFactorizationMPI` for use with `\\` or `solve`.
-Factorization is automatically cleaned up when garbage collected.
 """
 function LinearAlgebra.ldlt(A::SparseMatrixMPI{T}) where T
     return _create_mumps_factorization(A, true)
@@ -371,11 +365,7 @@ end
 """
     finalize!(F::MUMPSFactorizationMPI)
 
-Manually release MUMPS resources. This is a **collective operation** - all
-ranks must call it together for immediate cleanup.
-
-If the factorization has already been cleaned up (by automatic finalization
-or a previous manual call), this is a no-op but all ranks must still call it.
+Release MUMPS resources. Must be called on all ranks together.
 """
 function finalize!(F::MUMPSFactorizationMPI)
     # Check if already finalized (removed from registry)