fix(placement): prevent thundering herd with optimistic resource accounting and shadow state

High concurrency placement requests were causing severe "thundering herd" issues due to stale node metrics. The orchestrator would continuously schedule multiple sandboxes on the same seemingly "empty" node before it could report updated resource usage (the "invisibility gap").

This commit introduces active load prediction and optimistic resource reservation to ensure perfectly balanced placement even during metric reporting intervals.

Changes:
- fix(placement): factor `InProgress` pending resources into the `BestOfK` scoring calculation to predict expected load.
- fix(nodemanager): implement `OptimisticAdd` to immediately reserve resources upon successful placement, bridging the gap before async metric updates arrive.
- test(placement): refactor `SimulatedNode` into a `NodeSimulator` interface to support diverse node behavior simulations.
- test(placement): introduce `LaggyNode` to simulate real-world scenarios with stale/delayed node metrics.
- test(placement): add `BenchmarkPlacementDistribution` to visualize load distribution and verify the elimination of the thundering herd effect under high concurrency.

Signed-off-by: MorningTZH <morningtzh@yeah.net>

Author: morningtzh

packages/api/internal/orchestrator/nodemanager/node.go

@@ -177,3 +177,12 @@ func (n *Node) GetClient(ctx context.Context) (*clusters.GRPCClient, context.Con
 func (n *Node) IsNomadManaged() bool {
 	return n.NomadNodeShortID != UnknownNomadNodeShortID
 }
+
+func (n *Node) OptimisticAdd(res SandboxResources) {
+    n.metricsMu.Lock()
+    defer n.metricsMu.Unlock()
+    
+    // Directly accumulate to the current metrics view
+    n.metrics.CpuAllocated += uint32(res.CPUs)
+    n.metrics.MemoryAllocatedBytes += uint64(res.MiBMemory) * 1024 * 1024 // Note: CpuPercent is difficult to estimate, usually just updating Allocated is sufficient for the scheduling algorithm
+}

packages/api/internal/orchestrator/placement/placement.go

@@ -79,6 +79,14 @@ func PlaceSandbox(ctx context.Context, algorithm Algorithm, clusterNodes []*node
 		if err == nil {
 			node.PlacementMetrics.Success(sbxRequest.GetSandbox().GetSandboxId())
 
+			// Optimistic update: assume resources are occupied after successful creation.
+			// Manually update node.metrics with the newly allocated resources.
+			// This will be overwritten by the next real Metrics report for auto-correction.
+			node.OptimisticAdd(nodemanager.SandboxResources{
+				CPUs:      sbxRequest.GetSandbox().GetVcpu(),
+				MiBMemory: sbxRequest.GetSandbox().GetRamMb(),
+			})
+
 			return node, nil
 		}