feat: add eigen2 frequency pipeline and fail-closed validation

Implement MITC4 mass, constrained whitening, MKL FEAST, modal HDF5, and deterministic Value comparison. MSVC Debug builds; 394 of 395 tests pass. Original-model all-c residual and the documented S3 static contract conflict remain unresolved; this is an implementation checkpoint, not feature acceptance.

src/fesa/analysis/prepared_analysis.cpp

@@ -2,12 +2,14 @@
 
 #include <utility>
 
+#include "fesa/analysis/linear_frequency_procedure.h"
 #include "fesa/analysis/linear_static_procedure.h"
 #include "fesa/analysis/newton_iteration_log.h"
 #include "fesa/analysis/nonlinear_static_procedure.h"
 #include "fesa/app/output_paths.h"
 #include "fesa/io/abaqus/domain_mapper.h"
 #include "fesa/io/abaqus/input_reader.h"
+#include "fesa/results/eigen_results_writer.h"
 #include "fesa/results/nonlinear_results_writer.h"
 #include "fesa/results/results_writer.h"
 
@@ -34,12 +36,26 @@ Result<PreparedAnalysisInput> PrepareAnalysisInput(
 Result<PreparedAnalysisOutcome> ExecutePreparedAnalysis(
     const Domain& domain, LinearStaticProcedureExecutor& linear_executor,
     NonlinearStaticProcedureExecutor& nonlinear_executor,
+    const LinearFrequencyProcedureExecutor& frequency_executor,
     NewtonIterationLogWriter& log) {
   if (domain.Steps().Size() != 1U) {
     return Result<PreparedAnalysisOutcome>::Failure(Status::Failure(
         FailureCategory::kInput,
-        {{Severity::kError, "invalid-analysis-step-count", {}, "*STEP", {},
-          "Prepared analysis requires exactly one static step."}}));
+        {{Severity::kError,
+          "invalid-analysis-step-count",
+          {},
+          "*STEP",
+          {},
+          "Prepared analysis requires exactly one analysis step."}}));
+  }
+
+  if (domain.Steps()[0U].IsFrequency()) {
+    auto eigen = frequency_executor.Execute(domain);
+    if (!eigen.HasValue()) {
+      return Result<PreparedAnalysisOutcome>::Failure(eigen.GetStatus());
+    }
+    return Result<PreparedAnalysisOutcome>::Success(
+        PreparedAnalysisOutcome{std::move(eigen.Value())});
   }
 
   if (domain.Steps()[0U].IsNonlinearStatic()) {
@@ -64,7 +80,13 @@ Status FinalizePreparedAnalysisResult(
     const DerivedOutputPaths& paths, const Domain& domain,
     const PreparedAnalysisOutcome& outcome,
     const std::vector<Diagnostic>& diagnostics, ResultsWriter& linear_writer,
-    NonlinearResultsWriter& nonlinear_writer) {
+    NonlinearResultsWriter& nonlinear_writer,
+    EigenResultsWriter& eigen_writer) {
+  if (std::holds_alternative<EigenAnalysisState>(outcome)) {
+    return eigen_writer.Write(paths.results_path, domain,
+                              std::get<EigenAnalysisState>(outcome),
+                              diagnostics);
+  }
   if (std::holds_alternative<LinearStaticExecutionResult>(outcome)) {
     return linear_writer.Write(
         paths.results_path, domain,