Fix cross-thread Dispose NRE: do not null readBase under a live reader

TestCrossThreadCloneDisposeWhileReading crashed the test host on net48 x64 with
a NullReferenceException in ReadByte at *(readBase + pos): a clone being read on
thread A was disposed on thread B, and Dispose called ReleaseCurrentChunk(),
nulling readBase while thread A sat between its `pos < currentEnd` check and its
dereference.

Dispose now only zeroes currentEnd (the fail-fast gate) and no longer nulls
readBase. There is no native reference tied to the cursor (the DrainReclaimer
owns reclamation, and keeps the view mapped until the owning root closes), so a
stale readBase is harmless: the in-flight read completes against the still-mapped
view, and the zeroed currentEnd makes every subsequent read drop to the slow path
and throw AlreadyClosed. readBase is now only ever nulled by the reading thread
itself (Seek / EnsureCurrentChunk / clone setup), never cross-thread, so the race
is structurally eliminated. The fields are GC'd with the instance.

Latent on net10 (timing-lucky in CI); manifested as a host crash on net48 x64.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: paulirwin

src/Lucene.Net/Support/UnsafeChunkIndexInput.cs

@@ -503,17 +503,23 @@ protected override void Dispose(bool disposing)
             {
                 return;
             }
-            // Clear currentEnd so a racing reader's fast path (`pos < currentEnd`)
+            // Clear currentEnd so a future read's fast path (`pos < currentEnd`)
             // drops to the slow path and observes instanceClosed. Interlocked so the
             // 64-bit write can't tear on 32-bit runtimes.
+            //
+            // We deliberately do NOT null readBase here. Disposing an instance while
+            // another thread reads it (e.g. a slicer cascade disposing a slice that
+            // thread is mid-read, or a cross-thread clone Dispose) is racy: that
+            // reader may sit between its `pos < currentEnd` check and its
+            // `*(readBase + pos)` load, so nulling readBase under it would NRE/AVE.
+            // There is no native reference tied to the cursor (the reclaimer owns
+            // reclamation), so leaving readBase stale is harmless - the zeroed
+            // currentEnd already fails-fast every subsequent read, and the in-flight
+            // read completes safely against the still-mapped view (the reclaimer
+            // keeps it mapped until the owning root closes). The fields are GC'd with
+            // the instance.
             Interlocked.Exchange(ref currentEnd, 0L);
 
-            // Invalidate this instance's cursor cache. This only affects this input;
-            // the shared mapping (and its reclaimer) is closed by the owning root's
-            // DisposeChunkSource, NOT here, so disposing a clone or slice never tears
-            // down the mapping that sibling readers still depend on.
-            ReleaseCurrentChunk();
-
             DisposeChunkSource(disposing);
         }