fix(storage): DTypeSize reports in-memory stride, not Marshal.SizeOf

`UnmanagedStorage.DTypeSize` (exposed via `NDArray.dtypesize`) was
delegating to `Marshal.SizeOf(_dtype)`. For every numeric dtype that
matches, but for bool, `Marshal.SizeOf(typeof(bool)) == 4` because bool
is marshaled to win32 BOOL (32-bit). The in-memory layout of `bool[]`
is 1 byte per element, so every caller computing a byte offset as
`ptr + index * arr.dtypesize` was reading/writing 4× too far into the
buffer for bool arrays.

Switches to `_typecode.SizeOf()` which correctly returns 1 for bool and
matches `Marshal.SizeOf` for every other type. 21 existing call sites
(matmul, binary/unary/comparison/reduction ops, nan reductions, std/var,
argmax, random shuffle, boolean mask gather, etc.) now get the right
value without any downstream change.

The bug had been latent until the Phase 2 iterator migration started
routing more code paths through NpyIter.Copy and the new NDIterator
wrapper; it surfaced most visibly as `sliced_bool[mask]` returning the
wrong elements when the source was non-contiguous. With the root fix:

    var full = np.array(new[] { T,F,T,F,T,F,T,F,T });
    var sliced = full["::2"];            // [T,T,T,T,T] non-contig
    var result = sliced[new_bool_mask];  // now correct per-element

np.save.cs already special-cases bool before falling through to
`Marshal.SizeOf`, so serialization was unaffected. Remaining
Marshal.SizeOf references in the codebase are either in comments that
explain this exact issue, or in the `InfoOf<T>.Size` fallback that
only runs for types outside the 12 supported dtypes (e.g. Complex).

Tests: 6,748 / 6,748 passing on net8.0 and net10.0 with the CI filter
(TestCategory!=OpenBugs&TestCategory!=HighMemory).

Author: Nucs

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

@@ -141,8 +141,15 @@ public partial class UnmanagedStorage : ICloneable
 
         /// <summary>
         ///     The size in bytes of a single value of <see cref="DType"/>
+        ///     as stored in the unmanaged buffer.
         /// </summary>
-        /// <remarks>Computed by <see cref="Marshal.SizeOf(object)"/></remarks>
+        /// <remarks>
+        /// Returns the in-memory element stride, not the marshaling size.
+        /// For bool that is 1, not <see cref="Marshal.SizeOf(object)"/>'s 4
+        /// (bool is marshaled to win32 BOOL = int). All pointer arithmetic
+        /// over <c>Address</c> uses this value, so the in-memory layout is
+        /// the only correct reference.
+        /// </remarks>
         public int DTypeSize
         {
             get
@@ -152,7 +159,7 @@ public int DTypeSize
                     return IntPtr.Size;
                 }
 
-                return Marshal.SizeOf(_dtype);
+                return _typecode.SizeOf();
             }
         }