feat: wire V2 saturation analyzer into engine, gated by analyzerName

[ev-shindin]

Summary

Wire the V2 token-based saturation analyzer into the optimization engine, gated by analyzerName: "saturation" in the saturation scaling config. When active, it replaces the V1 percentage-based analyzer while keeping the rest of the pipeline (enforcer, limiter, decision converter) unchanged via an adapter pattern.

This PR also introduces the CostAwareOptimizer — the first ScalingOptimizer implementation for the V2 pipeline — which handles unlimited-mode multi-variant scaling with cost-based replica allocation.

Base branch: main (after PR #689 merge)
Depends on: PR #689 (saturation_v2 package)

Changes

Engine Integration (internal/engines/saturation/)

• V1/V2 split in engine.go: Refactor optimize() into optimizeV1() and optimizeV2(), gated by analyzerName == "saturation" from global config
• V2 fields on Engine struct: saturationV2Analyzer, capacityStore, optimizer — initialized once in NewEngine()
• optimizeV2() three-stage pipeline:
  1. Collect ModelScalingRequests (run V2 analyzer per model, pre-populate capacity store from deployments)
  2. Call optimizer.Optimize() across all models
  3. Apply enforcer per-model via bridge functions
• Enforcer bridge (engine_v2.go): extractTargetsFromDecisions, buildVariantAnalysesFromDecisions, applyEnforcedTargetsToDecisions — adapts V2 optimizer output to existing V1 enforcer interface
• Config pattern: Follows upstream's e.Config DI pattern with namespace-aware config loading (SaturationConfigForNamespace, ScaleToZeroConfigForNamespace)

CostAwareOptimizer (internal/engines/pipeline/)

• optimizer_interfaces.go: ScalingOptimizer interface and ModelScalingRequest type
• cost_aware_optimizer.go: Unlimited-mode optimizer that processes each model independently:
  • Scale-up: allocates replicas to most cost-efficient variant (lowest cost / perReplicaCapacity). Variants with pending replicas are not skipped — the analyzer already accounts for their capacity in the supply calculation, so RequiredCapacity > 0 means demand exceeds total supply including pending.
  • Scale-down: removes replicas from most expensive variant (highest absolute cost). The cheapest variant is protected at min 1 replica only when it is the last variant with replicas — this prevents scale-down deadlocks where the expensive variant's per-replica capacity exceeds spare but cheaper replicas could be removed.
  • Skips variants with zero capacity

Limiter Infrastructure (internal/engines/pipeline/)

• limiter_interfaces.go: New ResourcePool, ResourceConstraints, and ConstraintProvider interface — enables V2 limited-mode path (future GreedyBySaturationOptimizer)
• default_limiter.go: DefaultLimiter now implements ConstraintProvider via ComputeConstraints() (V2 path) alongside existing Limiter.Limit() (V1 path)
• type_inventory.go: Added GetResourcePools() to Inventory interface and TypeInventory implementation

What stays unchanged

Component	Why
Enforcer.EnforcePolicy()	Consumes []VariantSaturationAnalysis — provided by bridge adapter
convertSaturationTargetsToDecisions()	V1-only path, not touched
GPULimiter.Limit()	Applied globally after both V1 and V2 paths
applySaturationDecisions()	Consumes []VariantDecision — unchanged
saturation_v2 package	No changes to analyzer logic