Refactor AllocationManager and enhance debug tracking

Refactored `AllocationManager` to introduce intrusive allocation tracking with `AllocationHeader` structs for debug mode. Added lightweight allocation counters for non-debug mode. Enhanced memory leak detection with detailed stack traces and `MemoryLeakException`.

Simplified `AllocationInfo` by removing the `Allocator` property. Updated `AllocationOption` enum to remove `UnTracked` and clarified documentation.

Improved unsafe collections (`UnsafeArray`, `UnsafeStack`, etc.) with strongly-typed enumerators and better compatibility with `IEnumerable<T>`. Enhanced `UnsafeStack` with a dedicated `Enumerator` struct and consistent constructor parameters.

Refactored `MemoryLeakException` to support detailed allocation info and improved stack trace formatting. Simplified `MemoryUtility` by removing redundant null checks.

Added unit tests for `AllocationManager`, `UnsafeArray`, and `UnsafeStack` to validate memory management and functionality. Updated `Program.cs` with new examples.

Cleaned up namespaces, removed redundant `using` directives, and improved XML documentation. Applied `MethodImplOptions.AggressiveInlining` to performance-critical methods.

Misaki.HighPerformance.Test/UnitTest/Buffer/TestAllocationManager.cs

@@ -0,0 +1,61 @@
+using Misaki.HighPerformance.LowLevel;
+using Misaki.HighPerformance.LowLevel.Buffer;
+using Misaki.HighPerformance.LowLevel.Collections;
+
+namespace Misaki.HighPerformance.Test.UnitTest.Buffer;
+
+[TestClass]
+public class TestAllocationManager
+{
+    [TestInitialize]
+    public void Initialize()
+    {
+        AllocationManager.EnableDebugLayer();
+    }
+
+    [TestMethod]
+    public void ShouldNotLeakTest()
+    {
+        try
+        {
+            var array = new UnsafeArray<int>(10, Allocator.Persistent);
+            var array2 = new UnsafeArray<int>(10, Allocator.Persistent);
+
+            array.Dispose();
+            array2.Dispose();
+
+            AllocationManager.Dispose();
+        }
+        finally
+        {
+            var leaks = AllocationManager.LiveHeapAllocationCount;
+            Assert.AreEqual(0, leaks);
+        }
+    }
+
+    [TestMethod]
+    public void ShouldLeakTest()
+    {
+        var array = new UnsafeArray<int>(10, Allocator.Persistent);
+        var array2 = new UnsafeArray<int>(10, Allocator.Persistent);
+
+        try
+        {
+            AllocationManager.Dispose();
+        }
+        catch (MemoryLeakException)
+        {
+            var leaks = AllocationManager.LiveHeapAllocationCount;
+            Assert.AreEqual(2, leaks);
+
+            return;
+        }
+        finally
+        {
+            array.Dispose();
+            array2.Dispose();
+        }
+
+        Assert.Fail("Expected MemoryLeakException was not thrown.");
+    }
+}