arch: Apply faer-style Rust optimisation patterns to core search pipeline

Architecture Optimisation: Apply faer-style Rust Patterns

Context

Evaluation of faer (pure Rust linear algebra library) identified several advanced Rust optimisation patterns that are directly applicable to terraphim-ai's core search pipeline. These patterns complement the existing performance epic (#193) and automata refactor (#201) with concrete, proven techniques.

KB reference: cto-executive-system/knowledge/faer-rust-linear-algebra.md

Patterns to Evaluate and Apply

1. Move+Reborrow for Mutable Views (MatMut pattern)

faer's MatMut uses move semantics + reborrow instead of Copy to prevent aliased mutable access at compile time. This pattern could improve:

• AutomataPath and mutable graph traversal in terraphim_automata
• Mutable search context objects passed through the pipeline
• Any &mut aliasing that currently relies on runtime checks (RefCell, Mutex)

Benefit: Compile-time exclusive access guarantees without runtime overhead.

2. Runtime SIMD Dispatch

faer uses std::arch for runtime CPU feature detection (AVX-512/AVX2/SSE) with automatic dispatch to optimal codepaths. Applicable to:

• Aho-Corasick pattern matching hot path (currently delegated to aho-corasick crate, but custom SIMD could help with pre/post processing)
• Hash computation for knowledge graph lookups
• String comparison in thesaurus matching

Benefit: 2-4x throughput on SIMD-capable hardware without losing portability.

3. Zero-Copy View Types

faer's MatRef/MatMut provide zero-copy slicing with lifetime-bound subviews. Applicable to:

• Search result slices passed between pipeline stages
• Knowledge graph node/edge views (avoid cloning during traversal)
• Automata state views during matching (connects to #201 cache efficiency goal)

Benefit: Eliminate allocations in hot paths identified in #196 and #382.

4. Trait-Based Generic Configuration (Auto trait)

faer's Auto trait provides algorithm-specific hyperparameters tuned per scalar type. Applicable to:

• Search scoring functions that currently use runtime type checks or enum dispatch
• Automata builder configuration (different strategies for different corpus sizes)
• perf-warn style compile-time warnings when suboptimal configurations are used

Benefit: Zero-cost abstractions for configurable behaviour.

Relationship to Existing Issues

Existing Issue	How This Connects
#193 (Performance Epic)	Adds concrete Rust patterns to the roadmap
#201 (Automata Refactor)	Move+reborrow and SIMD patterns directly applicable
#196 (Excessive Cloning)	Zero-copy views are the solution pattern
#382 (HTTP client allocations)	Zero-copy patterns reduce allocation pressure
#200 (Search Relevance)	Trait-based config for scoring function dispatch

Implementation Approach

1. Audit: Profile current hot paths with cargo flamegraph to identify where these patterns give most ROI
2. Prototype: Apply move+reborrow pattern to one mutable context type, measure impact
3. Evaluate SIMD: Check if aho-corasick crate's SIMD is sufficient or if custom dispatch adds value
4. Zero-copy views: Introduce SearchResultRef / SearchResultMut view types for pipeline stages

Not In Scope

• Numerical linear algebra (faer's core domain) -- not relevant to terraphim
• Sparse matrix operations
• Rayon parallelism (already evaluated separately)

References

• faer docs: https://docs.rs/faer/latest/faer/
• faer repo: https://github.com/sarah-ek/faer-rs
• Rust Performance Book: https://nnethercote.github.io/perf-book/

Start by profiling the core search pipeline with cargo flamegraph, then compare the hot paths with the move+reborrow, SIMD dispatch, zero-copy view, and trait-based configuration patterns described here. Review the related issues #193, #201, #196, #382, and #200; completion would require a scoped prototype and measured evidence showing which pattern provides useful benefit.