Refactor and enhance math, memory, and utilities

Refactored `sincos` usage in `quaternion` to use tuple-based
returns for improved readability. Introduced a `random` struct
with methods for generating random values of various types
and dimensions, including ranges and directions. Added a
`DynamicArray` class for dynamic resizing and manipulation
of collections. Enhanced `SlotMap` with new methods for
safe access and updates.

Updated `uint` vector types with `NumericConvertable`
attributes for better type interoperability. Removed the
`MathUtilities` class and refactored `adj` and `adjInverse`
methods for encapsulation. Improved memory management
with `StackAllocator` and `UnsafeArray` enhancements.

Added geometry utilities like `AABB`, `OBB`, `Plane`, and
`SphereBounds` for 3D operations. Updated project
configuration for versioning and NuGet packaging.
Performed general code cleanup, improved validation, and
aligned with modern C# practices.

Misaki.HighPerformance.LowLevel/Collections/UnsafeStack.cs

@@ -1,11 +1,17 @@
 using Misaki.HighPerformance.LowLevel.Buffer;
 using Misaki.HighPerformance.LowLevel.Collections.Contracts;
-using Misaki.HighPerformance.LowLevel.Helpers;
+using Misaki.HighPerformance.LowLevel.Contracts;
+using Misaki.HighPerformance.LowLevel.Utilities;
 using System.Collections;
 using System.Runtime.CompilerServices;
 
 namespace Misaki.HighPerformance.LowLevel.Collections;
 
+/// <summary>
+/// Provides a high-performance, unsafe stack data structure for unmanaged types, supporting manual memory management
+/// and allocation control.
+/// </summary>
+/// <typeparam name="T">The type of elements stored in the stack. Must be an unmanaged type.</typeparam>
 public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
     where T : unmanaged
 {
@@ -24,15 +30,41 @@ public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
         return GetEnumerator();
     }
 
-    public UnsafeStack() : this(1, Allocator.Persistent)
+    /// <summary>
+    /// Invalid constructor, use <see cref="UnsafeStack(int, Allocator, AllocationOption)"/> or <see cref="UnsafeStack(int, ref AllocationHandle, AllocationOption)"/> instead.
+    /// </summary>
+    public UnsafeStack()
+        : this(0, Allocator.Invalid)
     {
     }
 
-    public UnsafeStack(int initialSize, Allocator allocator, AllocationOption allocationOption = AllocationOption.None)
+    /// <summary>
+    /// Initializes a new instance of the UnsafeStack class with the specified initial capacity and allocation options.
+    /// </summary>
+    /// <param name="initialCapacity">The number of elements the stack can initially hold. Must be greater than zero.</param>
+    /// <param name="handle">A reference to an AllocationHandle used to manage the underlying memory allocation for the stack.</param>
+    /// <param name="allocationOption">Specifies additional options for memory allocation. The default is AllocationOption.None.</param>
+    public UnsafeStack(int initialCapacity, ref AllocationHandle handle, AllocationOption allocationOption = AllocationOption.None)
     {
-        _array = new UnsafeArray<T>(initialSize, allocator, allocationOption);
+        _array = new UnsafeArray<T>(initialCapacity, ref handle, allocationOption);
     }
 
+    /// <summary>
+    /// Initializes a new instance of the UnsafeStack class with the specified initial capacity, allocator, and
+    /// allocation options.
+    /// </summary>
+    /// <param name="initialCapacity">The initial number of elements that the stack can hold. Must be greater than zero.</param>
+    /// <param name="allocator">The allocator to use for memory management of the stack's storage.</param>
+    /// <param name="allocationOption">The allocation option that determines how memory is allocated for the stack. The default is AllocationOption.None.</param>
+    public UnsafeStack(int initialCapacity, Allocator allocator, AllocationOption allocationOption = AllocationOption.None)
+        : this(initialCapacity, ref AllocationManager.GetAllocationHandle(allocator), allocationOption)
+    {
+    }
+
+    /// <summary>
+    /// Adds an element to the top of the stack.
+    /// </summary>
+    /// <param name="value">The element to add to the stack.</param>
     public void Push(T value)
     {
         if (_count >= _array.Count)
@@ -44,6 +76,11 @@ public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
         _count++;
     }
 
+    /// <summary>
+    /// Removes and returns the object at the top of the stack.
+    /// </summary>
+    /// <returns>The object removed from the top of the stack.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the stack is empty.</exception>
     public T Pop()
     {
         if (_count == 0)
@@ -55,6 +92,12 @@ public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
         return _array[_count];
     }
 
+    /// <summary>
+    /// Attempts to remove and return the object at the top of the stack.
+    /// </summary>
+    /// <param name="value">When this method returns, contains the object removed from the top of the stack, if the operation succeeded;
+    /// otherwise, the default value of <typeparamref name="T"/>.</param>
+    /// <returns>true if an object was successfully removed and returned from the stack; otherwise, false.</returns>
     public bool TryPop(out T value)
     {
         if (_count == 0)
@@ -68,6 +111,11 @@ public unsafe struct UnsafeStack<T> : IUnsafeCollection<T>
         return true;
     }
 
+    /// <summary>
+    /// Returns the item at the top of the stack without removing it.
+    /// </summary>
+    /// <returns>The item of type <typeparamref name="T"/> at the top of the stack.</returns>
+    /// <exception cref="InvalidOperationException">Thrown when the stack is empty.</exception>
     public readonly T Peek()
     {
         if (_count == 0)