feat(int64): add UnmanagedSpan extension methods for Span<T> parity

Implements Span<T>-equivalent extension methods for UnmanagedSpan<T>
and ReadOnlyUnmanagedSpan<T> with full long indexing support.

**Search Methods (return long)**
- IndexOf(T value) - first occurrence
- IndexOf(ReadOnlyUnmanagedSpan<T> value) - first sequence occurrence
- LastIndexOf(T value) - last occurrence
- LastIndexOf(ReadOnlyUnmanagedSpan<T> value) - last sequence occurrence
- IndexOfAny(T, T) / IndexOfAny(T, T, T) / IndexOfAny(span)
- LastIndexOfAny(T, T) / LastIndexOfAny(T, T, T) / LastIndexOfAny(span)
- BinarySearch(T) / BinarySearch(T, IComparer<T>)

**Predicates**
- Contains(T value) - existence check
- SequenceEqual(span) / SequenceEqual(span, comparer)
- StartsWith(span) / EndsWith(span)

**Sorting (IntroSort with long indices)**
- Sort() / Sort(IComparer<T>) / Sort(Comparison<T>)
- Sort(keys, items) - paired sort with values span

**Modification**
- Reverse() - in-place reversal
- Replace(oldValue, newValue) - in-place replacement

**Statistics**
- Count(T value) - occurrence count (returns long)
- CommonPrefixLength(span) - shared prefix length

All methods support >2B element spans via long indexing.

Author: Nucs

src/NumSharp.Core/Backends/Unmanaged/UnmanagedStorage.cs

@@ -176,7 +176,19 @@ public Shape Shape
         /// Returns an UnmanagedSpan representing this storage's memory.
         /// </summary>
         /// <remarks>This ignores completely slicing. Supports long indexing for arrays &gt; 2B elements.</remarks>
-        public unsafe UnmanagedSpan<T> AsSpan<T>() where T : unmanaged
+        public unsafe Span<T> AsSpan<T>() where T : unmanaged
+        {
+            if (!_shape.IsContiguous)
+                throw new InvalidOperationException("Unable to span a non-contiguous storage.");
+
+            return new Span<T>(Address, (int)Count);
+        }
+        
+        /// <summary>
+        /// Returns an UnmanagedSpan representing this storage's memory.
+        /// </summary>
+        /// <remarks>This ignores completely slicing. Supports long indexing for arrays &gt; 2B elements.</remarks>
+        public unsafe UnmanagedSpan<T> AsUnmanagedSpan<T>() where T : unmanaged
         {
             if (!_shape.IsContiguous)
                 throw new InvalidOperationException("Unable to span a non-contiguous storage.");