perf(saves): chunked worker handoff, LPT blob scheduling, heap pre-sizing

Replaces the per-entity round-robin ConcurrentQueue handoff between the game
loop and the serialization workers with pooled 4096-entity chunks published to
a single shared queue. The producer's per-entity cost drops from a synchronized
enqueue to a plain array store, and workers pulling whole chunks load-balance
dynamically: a worker busy with a thick entity simply takes fewer chunks.

Scheduling changes so indivisible multi-megabyte payloads no longer extend the
freeze tail:
- Persistence.SerializeAll pushes systems largest-first (LPT), using the
  previous save's SerializedLength (or the loaded file size on first save).
- Persistence self-payloads and entities whose previous size exceeds 1MB are
  published as dedicated single-entity chunks so they spread across workers
  instead of riding inside one shared chunk.
- Entity SerializedLength is stamped from the index at load so estimates exist
  on the first save after boot.

Worker heaps are pre-sized from the loaded save's .bin sizes (25% headroom) so
the first save doesn't pay copy-on-grow inside the freeze, and the drain loop
uses SpinWait backoff (never Sleep(1)) instead of hammering the queue head
while the producer works. Snapshot writing uses a 1MB FileStream buffer, and
per-worker entity/byte counts are logged at Debug for balance diagnostics.

Measured on a 24-core machine with a synthetic 10M-entity, 1.7GB world
(64/64/32MB system payloads, 24x 2MB thick entities) through the real
pipeline classes: freeze window 740ms -> 122-160ms steady state (~5-6x),
first save 490ms -> 330ms, steady-state allocations converge to zero, and
worker byte loads converge (previous max/min spread ~2x -> ~1.15x for the
small-entity stream).

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Projects/Server/Serialization/GenericPersistence.cs

@@ -29,6 +29,11 @@ public abstract class GenericPersistence : Persistence, IGenericSerializable
     public int SerializedPosition { get; set; }
     public int SerializedLength { get; set; }
 
+    private long _loadedFileLength;
+
+    // Scheduling estimate only: previous save's payload size, or the loaded file size before the first save.
+    internal long EstimatedSize => SerializedLength > 0 ? SerializedLength : _loadedFileLength;
+
     public GenericPersistence(string name, int priority) : base(priority)
     {
         Name = name;
@@ -37,7 +42,9 @@ public abstract class GenericPersistence : Persistence, IGenericSerializable
 
     public override void Serialize()
     {
-        World.PushToCache(this);
+        // Always a dedicated chunk: self-payloads can be arbitrarily large and must not
+        // ride inside a shared chunk where one worker would serialize them plus the chunk.
+        World.PushSingleToCache(this);
     }
 
     public override void WriteSnapshot(string savePath, HashSet<Type> typeSet)
@@ -74,6 +81,7 @@ public abstract class GenericPersistence : Persistence, IGenericSerializable
         }
 
         var fileLength = file.Length;
+        _loadedFileLength = fileLength;
 
         string error;