Add MrGameEng.Atlases: texture atlas builder, runtime loader and CLI tool

AtlasBuilder packs a directory tree of loose images into atlas pages plus
JSON metadata (deterministic shelf packing, incremental rebuilds, orphan
cleanup); TextureAtlas loads them back handing out Texture2DRegions, so
sprites from one page batch into a single draw call. The asset handle
generator maps .atlas files to TextureAtlas and skips page images.
Demonstrated in the sample (Assets/Atlases + 'atlas' console command),
wrapped as tools/MrGameEng.AtlasTool for build scripts.

Documented dependency exception: Atlases depends on Graphics and Assets.

tests/MrGameEng.Atlases.Tests/ShelfPackerTests.cs

@@ -0,0 +1,111 @@
+using MrGameEng.Atlases;
+using Xunit;
+
+namespace MrGameEng.Atlases.Tests;
+
+public class ShelfPackerTests
+{
+    private static List<PackItem> Squares(int count, int size) =>
+        Enumerable.Range(0, count).Select(i => new PackItem($"item{i:D3}", size, size)).ToList();
+
+    [Fact]
+    public void Pack_PlacesEveryItem_WithinPageBounds()
+    {
+        var result = ShelfPacker.Pack(Squares(50, 60), maxPageSize: 256, padding: 2);
+
+        Assert.Equal(50, result.Placements.Count);
+        foreach (var p in result.Placements)
+        {
+            var (pageWidth, pageHeight) = result.PageSizes[p.Page];
+            Assert.True(p.X >= 2 && p.Y >= 2);
+            Assert.True(p.X + p.Width <= pageWidth);
+            Assert.True(p.Y + p.Height <= pageHeight);
+        }
+    }
+
+    [Fact]
+    public void Pack_NoTwoPlacements_Overlap()
+    {
+        var items = new List<PackItem>();
+        var random = new Random(42);
+        for (var i = 0; i < 200; i++)
+        {
+            items.Add(new PackItem($"r{i:D3}", random.Next(4, 90), random.Next(4, 90)));
+        }
+
+        var result = ShelfPacker.Pack(items, maxPageSize: 512, padding: 2);
+
+        var byPage = result.Placements.GroupBy(p => p.Page);
+        foreach (var page in byPage)
+        {
+            var list = page.ToList();
+            for (var i = 0; i < list.Count; i++)
+            {
+                for (var j = i + 1; j < list.Count; j++)
+                {
+                    var a = list[i];
+                    var b = list[j];
+                    var separated =
+                        a.X + a.Width + 2 <= b.X || b.X + b.Width + 2 <= a.X ||
+                        a.Y + a.Height + 2 <= b.Y || b.Y + b.Height + 2 <= a.Y;
+                    Assert.True(separated, $"{a.Key} overlaps {b.Key} (padding included)");
+                }
+            }
+        }
+    }
+
+    [Fact]
+    public void Pack_Overflows_ToMultiplePages()
+    {
+        // 9 квадратов 100² на страницу 256² помещаются максимум по 4.
+        var result = ShelfPacker.Pack(Squares(9, 100), maxPageSize: 256, padding: 2);
+
+        Assert.True(result.PageSizes.Count >= 3);
+        Assert.Equal(Enumerable.Range(0, result.PageSizes.Count), result.Placements.Select(p => p.Page).Distinct().Order());
+    }
+
+    [Fact]
+    public void Pack_OversizedItem_GetsDedicatedPage()
+    {
+        var items = Squares(2, 30);
+        items.Add(new PackItem("huge", 500, 40));
+
+        var result = ShelfPacker.Pack(items, maxPageSize: 256, padding: 2);
+
+        var huge = result.Placements.Single(p => p.Key == "huge");
+        Assert.Single(result.Placements, p => p.Page == huge.Page);
+        Assert.True(result.PageSizes[huge.Page].Width >= 504);
+    }
+
+    [Fact]
+    public void Pack_IsDeterministic_RegardlessOfInputOrder()
+    {
+        var items = Squares(30, 20).Concat(Squares(10, 50).Select(i => i with { Key = "b" + i.Key })).ToList();
+        var shuffled = items.AsEnumerable().Reverse().ToList();
+
+        var a = ShelfPacker.Pack(items, 128, 2);
+        var b = ShelfPacker.Pack(shuffled, 128, 2);
+
+        Assert.Equal(
+            a.Placements.OrderBy(p => p.Key, StringComparer.Ordinal),
+            b.Placements.OrderBy(p => p.Key, StringComparer.Ordinal));
+    }
+
+    [Fact]
+    public void Pack_TrimsPages_ToPowerOfTwo()
+    {
+        var result = ShelfPacker.Pack(Squares(1, 50), maxPageSize: 2048, padding: 2);
+
+        Assert.Equal((64, 64), result.PageSizes.Single());
+    }
+
+    [Theory]
+    [InlineData(1, 1)]
+    [InlineData(64, 64)]
+    [InlineData(65, 128)]
+    [InlineData(2048, 2048)]
+    public void NextPowerOfTwo_RoundsUp(int value, int expected)
+    {
+        Assert.Equal(expected, ShelfPacker.NextPowerOfTwo(value));
+    }
+}