perf(shell): route local products through MKL and reduce Hessian storage work

src/fesa/math/dense_blas_internal.h

@@ -26,6 +26,20 @@ class ScopedSingleEquationThreads {
   bool restore_default_{false};
 };
 
+/// @brief Limits element-local dense work under the caller's default policy.
+/// @note Positive caller TLS overrides are retained. Default requests are
+/// restored on success and unwind; process-wide settings are never changed.
+class ScopedLocalDenseThreads {
+ public:
+  ScopedLocalDenseThreads() noexcept;
+  ScopedLocalDenseThreads(const ScopedLocalDenseThreads&) = delete;
+  ScopedLocalDenseThreads& operator=(const ScopedLocalDenseThreads&) = delete;
+  ~ScopedLocalDenseThreads();
+
+ private:
+  bool restore_default_{false};
+};
+
 /// @brief Converts a dense storage length to the private MKL integer type.
 /// @return The converted length or an uncategorized overflow failure.
 Result<MKL_INT> ToMklSize(std::size_t size);
@@ -39,13 +53,38 @@ Matrix MultiplyTransposeLeft(const Matrix& left, const Matrix& right);
 /// @throws std::length_error if the size exceeds the backend integer range.
 Vector MultiplyDiagonal(const Vector& diagonal, const Vector& rhs);
 
+/// @brief Writes one row-major outer product through MKL without allocation.
+/// @note Source arrays and destination must not alias. A nonfinite input
+/// returns false before writing; finite product overflow remains for the
+/// owner's gate. A zero dimension accepts null pointers and performs no backend
+/// call.
+/// @throws std::invalid_argument for null storage of a nonempty product.
+/// @throws std::length_error for dimensions outside the backend integer range.
+bool OuterProduct(const double* left, std::size_t rows, const double* right,
+                  std::size_t columns, double* destination);
+
+/// @brief Writes left times right-transpose to nonaliased contiguous storage.
+/// @note Inputs are row-major rows-by-inner and columns-by-inner. Nonfinite
+/// input returns false before writing. Finite output overflow is not hidden.
+/// Zero output dimensions accept null pointers; inner zero writes exact zeros.
+/// @throws std::invalid_argument for missing nonempty storage.
+/// @throws std::length_error for dimension or storage-size overflow.
+bool MultiplyTransposeRight(const double* left, std::size_t rows,
+                            const double* right, std::size_t columns,
+                            std::size_t inner, double* destination);
+
+/// @brief Distinguishes positive-factor failure from inverse failure.
+enum class CholeskyFailure { kNone, kPivot, kInverse };
+
 /// @brief Computes a lower Cholesky factor and its inverse with MKL LAPACK.
 /// @return False for a nonpositive pivot or nonfinite factor/inverse.
 /// @note Outputs are replaced only after both finite candidates succeed.
+/// The optional failure output is initialized even when validation throws.
 /// @throws std::invalid_argument for a nonsquare or nonfinite input.
 /// @throws std::length_error for a backend size overflow.
 bool CholeskyLowerAndInverse(const Matrix& matrix, Matrix& lower,
-                            Matrix& inverse_lower);
+                             Matrix& inverse_lower,
+                             CholeskyFailure* failure = nullptr);
 
 /// @brief Copies contiguous double values through the private BLAS backend.
 /// @param source Readable storage for size values when size is nonzero.