feat(streaming): enforce typed completion queues

Replace the flat deferred list, priority scan, unload bypass, and count-only execution cap with exact destination/control/unload/Near/Far FIFOs behind one typed frame meter. Price worker results before adoption, retain exact retry identity, reject stale generations without payload retention, and publish queue pressure through lifecycle diagnostics.

Tests: dotnet build AcDream.slnx -c Release --no-restore; dotnet test AcDream.slnx -c Release --no-restore (8138 passed, 5 skipped)

src/AcDream.App/Streaming/StreamingWorkBudgetOptions.cs

@@ -65,6 +65,31 @@ public sealed record StreamingWorkBudgetOptions(
         MaxGlRetireOperations,
         DestinationReserveFraction);
 
+    /// <summary>
+    /// Compatibility bridge for the pre-Slice-E quality setting. The former
+    /// landblock count now selects a complete work profile instead of acting
+    /// as a second hidden execution throttle. Four is the historical High
+    /// profile and therefore preserves this configured profile exactly.
+    /// </summary>
+    public StreamingWorkBudgetOptions ScaleForLegacyCompletionCount(int count)
+    {
+        if (count <= 0)
+            throw new ArgumentOutOfRangeException(nameof(count));
+
+        double scale = count / 4.0;
+        return this with
+        {
+            MaxUpdateMilliseconds = Math.Max(
+                0.25,
+                MaxUpdateMilliseconds * scale),
+            MaxCompletionAdmissions = Scale(MaxCompletionAdmissions, scale),
+            MaxAdoptedCpuBytes = Scale(MaxAdoptedCpuBytes, scale),
+            MaxEntityOperations = Scale(MaxEntityOperations, scale),
+            MaxGpuUploadBytes = Scale(MaxGpuUploadBytes, scale),
+            MaxGlRetireOperations = Scale(MaxGlRetireOperations, scale),
+        };
+    }
+
     private static double ParsePositiveDouble(string? value, double fallback) =>
         double.TryParse(
             value,
@@ -118,4 +143,22 @@ public sealed record StreamingWorkBudgetOptions(
 
         return percent / 100f;
     }
+
+    private static int Scale(int value, double scale)
+    {
+        if (scale >= int.MaxValue / (double)value)
+            return int.MaxValue;
+        return Math.Max(
+            1,
+            (int)Math.Round(value * scale, MidpointRounding.AwayFromZero));
+    }
+
+    private static long Scale(long value, double scale)
+    {
+        if (scale >= long.MaxValue / (double)value)
+            return long.MaxValue;
+        return Math.Max(
+            1L,
+            (long)Math.Round(value * scale, MidpointRounding.AwayFromZero));
+    }
 }