fix(render): particles draw unclipped, once, in their retail stage

Retail never clips a particle to a portal view: each emitter's polys
join the ONE alpha list during its owner cell's far-to-near walk turn
(LScape::draw @0x00506330 iterates block_draw_list reversed; DrawBlock
@0x005A17C0 walks cells; ShouldDrawParticles @0x0050FE60 gates by cell
and distance), and occlusion is the depth test at FlushAlphaList
@0x0059D2E0 (its float is a COUNT threshold - 0f = flush all). The
1d2f2f73 architecture instead re-submitted particles once per
OutsideView slice under that slice's hardware clip slot, which cut
effects at aperture boundaries and drew nothing when no outside slice
was in view (the cathedral look-north disappearance).

Now: unattached emitters submit once per frame by owner-cell kind
(outdoor landcells in the landscape stage, interior EnvCells in the
final world scope - new UnattachedEmitterCellScope filter); cell,
shell-route, barrier-static, and late-stage owners submit their
per-slice cone-cull UNION once with clipSlot 0; and particles emit in
the stage matching their PARENT CELL - an interior dynamic whose
sphere straddles an exit-portal plane keeps its mesh in both stages
(#118) but its particles move to the final pass, so the interior
stage can no longer repaint over them (the aperture-band star cut).

Also lands the inert Change-2 primitives for the AP-236 retirement
(candle-behind-door): RetailAlphaQueue.FlushFartherThan drains only
the far prefix without resetting sources, plus the executor
passthrough and the conservative look-in threshold helper - nothing
calls them yet.

User-gated 2026-08-29 round 2 at the Sanctuary Cathedral: spell and
recall stars cover the whole room at every camera direction including
north; waterfall containment holds on retail's depth/seal mechanism;
adjacent-room particles/lights, walls, Holtburg, recall unregressed
(paperdoll remains pre-existing intermittent #443). Register: AP-236
filed for the remaining barrier-order divergence.

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

src/AcDream.App/Rendering/RetailAlphaQueue.cs

@@ -239,6 +239,106 @@ internal sealed class RetailAlphaQueue : IWorldSceneAlphaFrame
         }
     }
 
+    /// <summary>
+    /// Drains only the entries at or beyond <paramref name="minViewerDistance"/>
+    /// and keeps every nearer entry queued with the frame open. This is the
+    /// pre/inter-building barrier semantics: retail's far→near land walk means
+    /// <c>DrawBuilding</c>'s <c>FlushAlphaList(0f)</c> @0x0059F2A0 can only
+    /// flush content from cells FARTHER than that building — a nearer emitter
+    /// has not been inserted yet and composites after the building at a later
+    /// flush (the float there is a COUNT threshold, not a depth). The batched
+    /// landscape has no per-cell walk, so the same outcome is restored by
+    /// draining the far prefix of the established far→near order (AP-236).
+    /// Sources are deliberately NOT reset: retained tokens must stay valid
+    /// for the remaining entries' later <see cref="Flush"/>.
+    /// </summary>
+    public void FlushFartherThan(float minViewerDistance)
+    {
+        if (!IsCollecting)
+            throw new InvalidOperationException("Retail alpha flush requires an active frame.");
+        if (_submissions.Count == 0)
+            return;
+
+        float threshold = NormalizeDistance(minViewerDistance);
+        SortRetailOrder();
+        int prefix = 0;
+        while (prefix < _submissions.Count
+               && _submissions[prefix].ViewerDistance >= threshold)
+        {
+            prefix++;
+        }
+
+        if (prefix == 0)
+            return;
+
+        try
+        {
+            EnsureTokenCapacity(prefix);
+            EnsureSourceCapacity(_sources.Count);
+            Array.Clear(_sourceDrawOffsets, 0, _sources.Count);
+
+            for (int sourceIndex = 0; sourceIndex < _sources.Count; sourceIndex++)
+            {
+                IRetailAlphaDrawSource source = _sources[sourceIndex];
+                int sourceCount = 0;
+                for (int i = 0; i < prefix; i++)
+                {
+                    RetailAlphaSubmission submission = _submissions[i];
+                    if (ReferenceEquals(submission.Source, source))
+                        _tokenScratch[sourceCount++] = submission.Token;
+                }
+
+                if (sourceCount > 0)
+                    source.PrepareAlphaDraws(_tokenScratch.AsSpan(0, sourceCount));
+            }
+
+            int start = 0;
+            while (start < prefix)
+            {
+                IRetailAlphaDrawSource source = _submissions[start].Source;
+                int end = start + 1;
+                while (end < prefix
+                       && ReferenceEquals(_submissions[end].Source, source))
+                    end++;
+
+                int count = end - start;
+                int sourceIndex = FindSourceIndex(source);
+                int firstPreparedDraw = _sourceDrawOffsets[sourceIndex];
+                source.DrawPreparedAlphaBatch(firstPreparedDraw, count);
+                _sourceDrawOffsets[sourceIndex] += count;
+                start = end;
+            }
+        }
+        catch
+        {
+            // Converge to the full-drain failure shape: the retained suffix
+            // cannot be trusted once a source threw mid-prepare/draw.
+            _submissions.Clear();
+            List<Exception>? resetFailures = null;
+            for (int i = 0; i < _sources.Count; i++)
+            {
+                try
+                {
+                    _sources[i].ResetAlphaSubmissions();
+                }
+                catch (Exception error)
+                {
+                    (resetFailures ??= []).Add(error);
+                }
+            }
+            _sources.Clear();
+            if (resetFailures is { Count: > 0 })
+            {
+                throw new AggregateException(
+                    "Retail alpha partial drain failed and its submissions could not be fully reset.",
+                    resetFailures);
+            }
+            throw;
+        }
+
+        _submissions.RemoveRange(0, prefix);
+    }
+
     public void EndFrame()
     {
         if (!IsCollecting)