[Text] Unicode and text layout optimizations (AvaloniaUI#21400)

* perf(text): O(1) width queries on ShapedBuffer, cached LB-class lookup

- ShapedBuffer: lazy, pooled cluster-prefix cache shared across Split;
  adds TotalGlyphAdvance / MeasureCharactersThatFit.
- GlyphRun/TextFormatterImpl/Skia GlyphRunImpl: read the cache, drop
  duplicate scans; SplitTextRuns now returns firstLength via out.
- LineBreakEnumerator: cache Next/PreviousClass per advance; remove
  unused LineBreakPairTable.
- Tests + benchmarks for the new paths and a dotnet-trace harness.

~1.32x faster / -5% alloc on the emoji-wrap micro-benchmark; no
observable behaviour or public API change.

* perf(TextFormatting): inline LineBreakEnumerator rule dispatch

Replace the BreakUnitDelegate[] s_rules array dispatch in
LineBreakEnumerator.ExecuteRules with a sequence of direct static
calls and a `goto Done` early-exit. This removes 42 indirect calls
per codepoint and lets the JIT reason across rule boundaries, which
in turn makes [MethodImpl(AggressiveInlining)] meaningful — JIT
cannot inline through delegate.Invoke, so the attribute was a no-op
in the previous shape.

Selectively apply AggressiveInlining to the small single-condition
rules (LB03, LB04, LB06, LB07, LB08a, LB11–LB15d, LB18, LB20,
LB21b, LB22, LB29, LB31) and let the JIT decide on the larger ones
to avoid bloating the merged ExecuteRules.

The static BreakUnitDelegate[] s_rules array is removed.

Benchmarks (BDN default job, --inProcess, N=13–22, rel. StdDev <1.5%):

  UnicodeBreakEnumeratorBenchmark.LineBreakEnumerator_Sequence
    Ascii          154.6 µs -> 24.84 µs  (6.22x)
    Bmp            190.2 µs -> 32.81 µs  (5.80x)
    Supplementary  227.6 µs -> 37.56 µs  (6.06x)

  TextLayoutProfile.BuildEmojisWrapped
    Before (branch, pre-inline)  804.5 µs / 570.15 KB
    After  (branch, post-inline) 547.0 µs / 570.15 KB  (-32.0%)
    vs upstream/master (1061 µs) -> ~1.94x total speedup

No allocation change; CPU-only dispatch reshape. All
LineBreakEnumerator unit tests pass (5/5).

* Refactor ShapedBuffer to share pool storage via IRef + generation counter

Wrap the ArrayPool-rented glyph and cluster-cache arrays in a small
PooledArray<T> disposable and expose them through IRef<T>. Split children
and WithBidiLevel aliases now Clone() the refs instead of borrowing raw
pool arrays, so the backing storage survives until every sibling has
been disposed - eliminating the UAF risk that existed when a parent was
disposed before its children.

Add a per-glyph-holder generation counter (Volatile.Read / Interlocked
.Increment). The indexer setter bumps the counter on every write, and
EnsureClusterCache compares its recorded generation against the holder's
current value, rebuilding on mismatch. This lets us drop the previous
"no mutation after Split/WithBidiLevel" contract: mutations performed
through any sibling now propagate to the others' caches transparently.

Dispose is made idempotent via a _disposed guard so overlapping cache
eviction and TextLine teardown only release the IRefs once.

Adds ShapedBufferSharedStorageTests covering sibling lifetime,
Dispose idempotency, and generation-driven cache invalidation across
Split children and WithBidiLevel aliases.

* test(ShapedBuffer): cover cluster-cache sharing across Split/WithBidiLevel aliases

Add a regression test hook (`ClusterPrefix`) exposing the
backing cluster-prefix array reference, plus two tests that mutate a
parent buffer before aliasing it and assert the alias reuses the
parent's pooled prefix array instead of rebuilding. Guards against
forgetting to propagate `_cacheGeneration` to alias buffers, which
would silently defeat the cached-split fast path.

* Correctly use MathUtilities.LessThanOrClose

---------

Co-authored-by: Julien Lebosquain <julien@lebosquain.net>

Author: Gillibald

.gitignore

@@ -224,3 +224,5 @@ src/Browser/Avalonia.Browser/staticwebassets
 # Claude agent worktrees
 .claude/worktrees/
 /.claude/settings.local.json
+/planning
+BenchmarkDotNet.Artifacts.*

src/Avalonia.Base/Media/GlyphRun.cs

@@ -684,15 +684,26 @@ private GlyphRunMetrics CreateGlyphRunMetrics()
             }
 
             var height = GlyphTypeface.Metrics.LineSpacing * Scale;
-            var widthIncludingTrailingWhitespace = 0d;
 
             var trailingWhitespaceLength = GetTrailingWhitespaceLength(isReversed, out var newLineLength, out var glyphCount);
 
-            for (var index = 0; index < _glyphInfos.Count; index++)
+            // when our glyph source is a ShapedBuffer (the common case every
+            // shape result flows through one), it already maintains a cluster-width
+            // prefix sum we can read in O(1) instead of summing all advances here.
+            double widthIncludingTrailingWhitespace;
+
+            if (_glyphInfos is TextFormatting.ShapedBuffer shapedBuffer)
+            {
+                widthIncludingTrailingWhitespace = shapedBuffer.TotalGlyphAdvance;
+            }
+            else
             {
-                var advance = _glyphInfos[index].GlyphAdvance;
+                widthIncludingTrailingWhitespace = 0d;
 
-                widthIncludingTrailingWhitespace += advance;
+                for (var index = 0; index < _glyphInfos.Count; index++)
+                {
+                    widthIncludingTrailingWhitespace += _glyphInfos[index].GlyphAdvance;
+                }
             }
 
             var width = widthIncludingTrailingWhitespace;

src/Avalonia.Base/Media/TextFormatting/ShapedBuffer.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Buffers;
 using System.Collections.Generic;
-using System.Threading;
 using Avalonia.Media;
 using Avalonia.Media.TextFormatting;
 using Avalonia.Platform;
@@ -39,18 +38,14 @@ public GlyphRunImpl(GlyphTypeface glyphTypeface, double fontRenderingEmSize,
             _glyphIndices = new ushort[count];
             _glyphPositions = new SKPoint[count];
 
-            var currentX = 0.0;
-
+            // GetGlyphWidths needs _glyphIndices populated before the
+            // per-glyph bounds can be fetched, so this walk has to come
+            // first. It deliberately does no other work — positions and
+            // runBounds are built together in the fused walk below, using
+            // a single currentX accumulator.
             for (int i = 0; i < count; i++)
             {
-                var glyphInfo = glyphInfos[i];
-                var offset = glyphInfo.GlyphOffset;
-
-                _glyphIndices[i] = glyphInfo.GlyphIndex;
-
-                _glyphPositions[i] = new SKPoint((float)(currentX + offset.X), (float)offset.Y);
-
-                currentX += glyphInfos[i].GlyphAdvance;
+                _glyphIndices[i] = glyphInfos[i].GlyphIndex;
             }
 
             // Ideally the requested edging should be passed to the glyph run.
@@ -67,26 +62,39 @@ public GlyphRunImpl(GlyphTypeface glyphTypeface, double fontRenderingEmSize,
 
             using var font = CreateFont(defaultTextOptions);
 
-            var runBounds = new Rect();
             var glyphBounds = ArrayPool<SKRect>.Shared.Rent(count);
 
-            font.GetGlyphWidths(_glyphIndices, null, glyphBounds.AsSpan(0, count));
+            try
+            {
+                font.GetGlyphWidths(_glyphIndices, null, glyphBounds.AsSpan(0, count));
 
-            currentX = 0;
+                // build _glyphPositions and union runBounds in a
+                // single pass. Replaces the previous two separate walks (each
+                // maintaining its own currentX) each glyphInfo is read once,
+                // and one accumulator covers both outputs.
+                var currentX = 0.0;
+                var runBounds = new Rect();
 
-            for (var i = 0; i < count; i++)
-            {
-                var gBounds = glyphBounds[i];
-                var advance = glyphInfos[i].GlyphAdvance;
+                for (int i = 0; i < count; i++)
+                {
+                    var glyphInfo = glyphInfos[i];
+                    var offset = glyphInfo.GlyphOffset;
+                    var gBounds = glyphBounds[i];
 
-                runBounds = runBounds.Union(new Rect(currentX + gBounds.Left, gBounds.Top, gBounds.Width, gBounds.Height));
+                    _glyphPositions[i] = new SKPoint((float)(currentX + offset.X), (float)offset.Y);
 
-                currentX += advance;
-            }
-            ArrayPool<SKRect>.Shared.Return(glyphBounds);
+                    runBounds = runBounds.Union(new Rect(currentX + gBounds.Left, gBounds.Top, gBounds.Width, gBounds.Height));
+
+                    currentX += glyphInfo.GlyphAdvance;
+                }
 
-            BaselineOrigin = baselineOrigin;
-            Bounds = runBounds.Translate(new Vector(baselineOrigin.X, baselineOrigin.Y));
+                BaselineOrigin = baselineOrigin;
+                Bounds = runBounds.Translate(new Vector(baselineOrigin.X, baselineOrigin.Y));
+            }
+            finally
+            {
+                ArrayPool<SKRect>.Shared.Return(glyphBounds);
+            }
         }
 
         public double FontRenderingEmSize { get; }