Quantize normalized coordinates to the F2Dot14 grid

An animated axis sweeps through arbitrary float user values; without
quantization every frame produced a fresh normalized position and a
fresh clone in the per-source variation cache, growing it without bound
across repeated sweeps.

Snap each coordinate to 1/16384 after avar correction. That is the
resolution the font binary itself stores - gvar, avar and the item
variation stores speak F2Dot14 - so no representable position is lost,
while a swept axis lands on at most 32769 distinct cache entries and
sub-resolution user values collapse to one clone (pinned by tests at the
position and clone-identity level).

Author: Gillibald

src/Avalonia.Base/Media/GlyphTypeface.cs

@@ -1616,6 +1616,13 @@ internal NormalizedVariationPosition CreateNormalizedPosition(
                     normalizedValue = _avarTable.Remap(i, normalizedValue);
                 }
 
+                // Quantize to the F2Dot14 grid (1/16384) the font binary itself uses for
+                // normalized coordinates — gvar, avar and the item variation stores cannot
+                // represent a finer position, so this loses nothing. It also bounds the
+                // per-source variation-clone cache under animation: a swept axis lands on
+                // at most 32769 distinct positions instead of one per float progress value.
+                normalizedValue = MathF.Round(normalizedValue * 16384f) / 16384f;
+
                 if (normalizedValue != 0f)
                 {
                     normalized ??= new Dictionary<OpenTypeTag, float>(axes.Length);

tests/Avalonia.Base.UnitTests/Media/GlyphTypefaceVariationTests.cs

@@ -161,6 +161,24 @@ public void CreateNormalizedPosition_Ignores_Unknown_Axes()
             Assert.False(position.TryGetCoordinate(bogus, out _));
         }
 
+        [Fact]
+        public void CreateNormalizedPosition_Quantizes_To_The_F2Dot14_Grid()
+        {
+            // Normalized coordinates are quantized to the 1/16384 grid the font binary
+            // uses, so user values that differ below that resolution produce the SAME
+            // position — this is what keeps the variation-clone cache bounded when an
+            // axis is animated through arbitrary float values.
+            var typeface = LoadTypeface(InterVariableAsset);
+
+            var a = typeface.CreateNormalizedPosition(Settings((s_wghtTag, 700)));
+            var b = typeface.CreateNormalizedPosition(Settings((s_wghtTag, 700.001)));
+
+            Assert.Equal(a, b);
+
+            Assert.True(a.TryGetCoordinate(s_wghtTag, out var wght));
+            Assert.Equal(MathF.Round(wght * 16384f) / 16384f, wght);
+        }
+
         [Fact]
         public void CreateNormalizedPosition_Uses_Named_Instance_Coordinates()
         {

tests/Avalonia.Base.UnitTests/Media/GlyphTypefaceWithVariationTests.cs

@@ -270,6 +270,23 @@ public void WithVariations_Shares_Clones_Between_Settings_That_Normalize_Equal()
             Assert.Same(atMax, clamped);
         }
 
+        [Fact]
+        public void WithVariations_Shares_Clones_Within_A_Quantization_Cell()
+        {
+            // Under animation an axis sweeps through arbitrary float user values; the
+            // F2Dot14 quantization in CreateNormalizedPosition collapses sub-resolution
+            // differences so the sweep reuses clones instead of growing the cache
+            // per progress value.
+            var gt = LoadTypeface(InterVariableAsset);
+
+            var a = gt.WithVariations(new FontVariationSettings(
+                new[] { new FontVariation(s_wghtTag, 700) }));
+            var b = gt.WithVariations(new FontVariationSettings(
+                new[] { new FontVariation(s_wghtTag, 700.001) }));
+
+            Assert.Same(a, b);
+        }
+
         [Fact]
         public void WithVariations_Selects_Named_Instance_By_Index()
         {