fix(CodeEditor.Rendering): gap-only cache build — eliminate stale-cache double-draw blur

Extend the gap-only base pass to the GlyphRun cache build (P1-CE-05).

Previously the cache was built with [full-base-token + syntax tokens]. When the
stale GlyphRun cache (fast-path B) was replayed via DrawGlyphRun, the base token's
GlyphRun was drawn first then overwritten by syntax tokens — opaque so no blur.
But the live first-render path (before cache built) used DrawGlyphRun twice on the
same pixels, which CAN cause ClearType subpixel artifacts on some DPI/GPU combos.

Now both paths are consistent: gap tokens (uncovered spans only) + syntax tokens.
Each screen character is drawn exactly once in both live and cached render paths.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: abbaye

Sources/Editors/WpfHexEditor.Editor.CodeEditor/Controls/CodeEditor.Rendering.cs

@@ -2902,15 +2902,32 @@ private void RenderTextContent(DrawingContext dc)
                     }
 
                     // ── P1-CE-05: Build GlyphRun cache after first render ─────────────
-                    // Cache for the base-pass token too when using external highlighter.
+                    // Cache gap tokens + syntax tokens so the stale-cache path (DrawGlyphRun)
+                    // renders each character exactly once — matching the gap-only live pass.
                     if (_glyphRenderer != null)
                     {
-                        var allCacheTokens = hasExternalHighlighter
-                            ? Enumerable.Concat(
-                                new[] { new Helpers.SyntaxHighlightToken(
-                                    0, line.Text.Length, line.Text, EditorForeground) },
-                                renderTokens)
-                            : (IEnumerable<Helpers.SyntaxHighlightToken>)renderTokens;
+                        IEnumerable<Helpers.SyntaxHighlightToken> allCacheTokens;
+                        if (hasExternalHighlighter)
+                        {
+                            // Build gap segments (chars not covered by any syntax token).
+                            var gapTokens = new List<Helpers.SyntaxHighlightToken>();
+                            int gc = 0;
+                            foreach (var tok in renderTokens.OrderBy(t => t.StartColumn))
+                            {
+                                int ts2 = Math.Max(0, tok.StartColumn);
+                                int te2 = Math.Min(line.Text.Length, tok.StartColumn + tok.Length);
+                                if (ts2 > gc)
+                                    gapTokens.Add(new Helpers.SyntaxHighlightToken(gc, ts2 - gc, line.Text.Substring(gc, ts2 - gc), EditorForeground));
+                                gc = Math.Max(gc, te2);
+                            }
+                            if (gc < line.Text.Length)
+                                gapTokens.Add(new Helpers.SyntaxHighlightToken(gc, line.Text.Length - gc, line.Text[gc..], EditorForeground));
+                            allCacheTokens = Enumerable.Concat(gapTokens, renderTokens);
+                        }
+                        else
+                        {
+                            allCacheTokens = renderTokens;
+                        }
 
                         line.GlyphRunCache     = _glyphRenderer.BuildLineGlyphRuns(allCacheTokens, SyntaxUrlColor, line.Text);
                         line.IsGlyphCacheDirty = false;