Task: Wire G2 (Two-Factor Gaussian) into the system: factory, seed data, config storage, Qt UI

New structs in ores.analytics.quant, one per process type, living beside their process headers:

• two_factor_gaussian_params: kappa_x, kappa_y, theta, sigma_x, sigma_y, rho, initial_rate (all double). Lives at ores.analytics.quant/include/ores.analytics.quant/service/processes/two_factor_gaussian_params.hpp.
• For the existing 1-factor models, group their params into structs too so the mapping layer can target them uniformly:
  • vasicek_params: kappa, theta, sigma, initial_rate
  • cox_ingersoll_ross_params: kappa, theta, sigma, initial_rate
  • hull_white_params: kappa, theta, sigma, initial_rate
• Each process header gains a constructor taking the params struct (or a new constructor overload).
• No DB tables, no codegen — just plain C++ structs.

Full codegen entity (via compass add entity) scoped to ores.synthetic:

• Domain struct: yield_curve_process_parameter_definition with process_type_code (FK to yield_curve_process_types.code), parameter_name, description (rich user-facing text), data_type (always "double" for now), default_value, min_value, max_value, display_order, plus standard provenance columns. Unique key on (process_type_code, parameter_name).
• DB table + notify trigger: standard codegen output.
• Read-only (is_readonly: true in the codegen model) — managed via seed data only, not user-editable through the UI.
• Seed data: rows for all 4 process types (see step 5).
• Codegen layers: domain struct, DB schema, CRUD repository, NATS eventing, Qt MDI window + detail dialog (read-only).

Added as a has_many child of ir_curve_generation_config (same pattern as gmm_component on fx_spot_generation_config):

• Domain struct: ir_curve_generation_config_process_parameter_value with config_id (FK to ir_curve_generation_config), parameter_definition_id (FK to definitions), parameter_value (double). Unique key on (config_id, parameter_definition_id).
• DB trigger: validates that the definition's process_type_code matches the config's process_type.
• Config domain struct: ir_curve_generation_config gains std::vector<…> parameters (replacing the flat kappa, theta, sigma, initial_rate fields). The codegen has_many handles child save/load in the repository.
• Codegen layers: domain struct, DB schema with FK trigger, CRUD, NATS eventing.

New file: ores.synthetic.api/include/ores.synthetic.api/domain/yield_curve_process_parameter_mapping.hpp

// Pure function: parameter rows → strongly-typed process.
// Dispatches on process_type (lowercased).
// Throws std::invalid_argument if:
//   - any required parameter is missing from the rows
//   - any row has a parameter name not declared for this process_type
//   - any value is outside the definition's [min_value, max_value]
std::unique_ptr<ores::analytics::quant::domain::IYieldCurveProcess>
map_parameters_to_yield_curve_process(
    const std::string& process_type,
    const std::vector<
        ores::synthetic::domain::ir_curve_generation_config_process_parameter_value>& parameters,
    std::uint32_t seed,
    double dt);

Implementation: for each known process_type, build a std::map<string, double> from the rows, validate that the set of keys exactly matches the expected set for that type (no missing, no unexpected), extract each named value, construct the appropriate typed-params struct, and construct the process.

synthetic_yield_curve_process_types_populate.sql: add TWO_FACTOR_GAUSSIAN row.

New synthetic_yield_curve_process_parameter_definitions_populate.sql: one row per parameter per process type:

• Vasicek (4): kappa, theta, sigma, initial_rate
• Cox-Ingersoll-Ross (4): kappa, theta, sigma, initial_rate (initial_rate min=0)
• Hull-White (4): kappa, theta, sigma, initial_rate
• Two-Factor Gaussian (7): kappa_x (κ ≥ 0), kappa_y (κ ≥ 0), theta, sigma_x (≥ 0), sigma_y (≥ 0), rho ([-1,1]), initial_rate

Each row has a rich description field explaining what the parameter means — this is the text users see in the UI.

One-shot SQL script:

1. For every existing ir_curve_generation_config row, insert parameter-value rows for kappa, theta, sigma, initial_rate, referencing the corresponding parameter definitions.
2. Drop the flat columns from ores_synthetic_ir_curve_generation_configs_tbl.
3. Drop the now-superseded CHECK constraints (initial_rate > 0= for CIR, sigma > 0=).

• ir_curve_feed.cpp (line 276): replace the make_yield_curve_process(cfg.process_type, cfg.kappa, …, cfg.sigma, cfg.initial_rate, …) call with map_parameters_to_yield_curve_process(cfg.process_type, cfg.parameters, seed, dt).
• ir_curve_preview_handler.hpp (lines 114, 189): same replacement.
• simulate_handler.hpp (line 134): same replacement.
• simulate_ir_curve_paths_protocol.hpp: replace flat kappa=/=theta=/=sigma=/=initial_rate fields with a std::vector<parameter_spec> where parameter_spec = {parameter_name, parameter_value}.
• preview_ir_curve_shape_protocol.hpp: same treatment.

IrCurveGenerationConfigDetailDialog:

• Remove kappaEdit=/=thetaEdit=/=sigmaEdit=/=initialRateEdit from the .ui file and .cpp.
• Add a QTableWidget with columns: Parameter (read-only, from definition's description), Value (QDoubleSpinBox).
• When process_type changes: clear table, fetch definitions for the new type, add rows with default_value and min=/=max from the definition.
• updateUiFromConfig(): populate table from config.parameters.
• updateConfigFromUi(): read values back from table into config.parameters.
• Validation: per-row min/max enforced by the spin boxes + a summary check on save.