Implicit solver: fem kernels (tet4/10, hex8, hex20), sparse Cholesky, block Lanczos, solve.* commands (M4) (#23)

* Renumber the layer table for solver crates: fem at L1, solver at L2, fsi at L3

L0 model -> L1 geometry, mesh, fem, decks, render -> L2 solver (explicit, lbm later)
-> L3 fsi (later) -> L4 doc -> L5 io -> L6 engine -> L7 ui-egui, mcp -> apps.
UI_MIN_LAYER moves to 7, the testkit sits above it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* modelcraft-fem: element kernels for tet4, tet10, hex8 (full, incompatible modes), hex20 (full, reduced)

Shape functions, Gauss and conical-product quadrature, stiffness, consistent and HRZ-lumped
mass, body forces, consistent pressure loads on faces, integration-point stresses and their
least-squares extrapolation to nodes, isotropic and orthotropic elasticity. The element table is
one row per kind, so wedges, shells and beams are added locally.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* modelcraft-solver: linear static and frequency analysis with an analytic verification suite

Assembly from the resolved model on the node graph, boundary conditions by elimination,
consistent pressure, gravity and body-force loads, nested-dissection ordering, sparse up-looking
Cholesky with a factor-size cap, reactions, integration-point and nodal-averaged stresses, von
Mises; shift-invert block Lanczos with full reorthogonalization for natural modes, participation
and effective mass. ADR 0001 records the own-linear-algebra decision (determinism, wasm).

Verified against closed forms: displacement and traction patch tests for every element, cantilever
tip deflection (Timoshenko) with convergence rates, Lamé cylinder, Kirsch hole (Kt -> 3),
cantilever and free-free beam frequencies with six rigid-body modes.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* Engine: solve.static, solve.frequency and solve.probe; results kept in the session

Results are stored per step, restored on a failed command and cleared when the model changes.
Caps (degrees of freedom, factor entries, Lanczos vectors) may only be lowered; hostile parameters
are tested against a solvable session.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* docs: implicit solver architecture, roadmap M4, parity and references

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* Simplify the solver: shared face integration, block assembly, cached extrapolation

- model: one face integrator (nodal::face_normal_weights) for tractions and pressures
- fem: mid-side tables from ElementKind::edges, orthotropic via inverse3, symmetric
  accumulation without a symmetrize pass, incompatible-mode recovery without K_uu, model's
  coordinate check, dead table rows removed
- solver: one pattern search per node pair (block, scalar and diagonal adds), extrapolation built
  once per element type, reactions from the prescribed rows only, matrices dropped after
  restriction, the free-body shift keyed on the factorization error, step selection in the solver,
  Error::Element naming the element
- engine: the solver owns the default step and the shift check; the model comparison runs once

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

* docs: results are stamped with the session revision

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01NmAttHhUZTokgPeEJia8sm

---------

Co-authored-by: jyviko <2501648+jyviko@users.noreply.github.com>
Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

crates/solver/src/lib.rs

@@ -0,0 +1,89 @@
+//! ModelCraft's implicit solver: linear static and frequency analysis of a model's steps.
+//!
+//! The pipeline, for one step of a [`modelcraft_model::Model`]:
+//! 1. **System** ([`system`]): the model is resolved; every section's elements become solid
+//!    elements with their material's elasticity and the section's formulation
+//!    ([`modelcraft_fem`] kernels); the step's boundary conditions give the prescribed degrees of
+//!    freedom, its loads the load vector (forces and tractions as the model distributes them,
+//!    consistent pressure loads, gravity and body forces).
+//! 2. **Assembly** ([`sparse`]) on the node graph, elements in label order.
+//! 3. **Ordering** ([`ordering`]): nested dissection of the nodes; the free degrees of freedom
+//!    are numbered in that order and the prescribed ones eliminated (u_p moved to the right-hand
+//!    side), with no penalty numbers.
+//! 4. **Solution** ([`cholesky`]): sparse Cholesky; reactions K u − f at the prescribed degrees
+//!    of freedom; stresses at the integration points, extrapolated and averaged at the nodes, and
+//!    von Mises. Frequency analysis ([`eigen`]) runs shift-invert block Lanczos on the same
+//!    kind of factorization.
+//!
+//! Everything is sequential and in a fixed order, so the same model gives the same numbers bit
+//! for bit; sizes and iterations are capped by [`Limits`].
+#![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
+#![forbid(unsafe_code)]
+// Matrix kernels read as the textbook formulas with index loops.
+#![allow(clippy::needless_range_loop)]
+
+pub mod analysis;
+pub mod cholesky;
+pub mod eigen;
+pub mod ordering;
+pub mod sparse;
+pub mod system;
+
+pub use analysis::{
+    ElementStress, FrequencyOptions, FrequencyResult, MassKind, Mode, StaticResult, Stats, StepResult, solve_frequency, solve_static,
+};
+
+#[derive(Debug, Clone, PartialEq, thiserror::Error)]
+pub enum Error {
+    #[error(transparent)]
+    Model(#[from] modelcraft_model::Error),
+    #[error("invalid input: {0}")]
+    Invalid(String),
+    #[error("not supported yet: {0}")]
+    NotSupported(String),
+    /// An element kernel failed (inverted geometry, a formulation it lacks, …).
+    #[error("element {label}: {source}")]
+    Element { label: u32, source: modelcraft_fem::Error },
+    /// The stiffness (or shifted matrix) is singular.
+    #[error("{0}")]
+    Singular(String),
+    #[error("limit reached: {0}")]
+    Limit(String),
+    #[error("did not converge: {0}")]
+    NotConverged(String),
+    /// A broken internal invariant (a bug), reported instead of a panic.
+    #[error("internal error: {0}")]
+    Internal(String),
+}
+
+pub type Result<T> = std::result::Result<T, Error>;
+
+impl Error {
+    /// A kernel error, naming the element.
+    pub fn element(label: u32, source: modelcraft_fem::Error) -> Error {
+        Error::Element { label, source }
+    }
+}
+
+/// Caps on the size of a solution.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Limits {
+    /// Degrees of freedom of the mesh.
+    pub max_dofs: usize,
+    /// Entries of the Cholesky factor (8 bytes each); also bounds the Lanczos basis memory.
+    pub max_factor_entries: usize,
+    /// Lanczos vectors (iterations × block size).
+    pub max_lanczos_vectors: usize,
+}
+
+impl Limits {
+    pub const MAX_DOFS: usize = 6_000_000;
+    pub const MAX_FACTOR_ENTRIES: usize = 400_000_000;
+    pub const MAX_LANCZOS_VECTORS: usize = 3_000;
+}
+
+impl Default for Limits {
+    fn default() -> Limits {
+        Limits { max_dofs: Limits::MAX_DOFS, max_factor_entries: Limits::MAX_FACTOR_ENTRIES, max_lanczos_vectors: Limits::MAX_LANCZOS_VECTORS }
+    }
+}