Read the cached file length without the page-cache lock

The committed file length was read under the page cache's lock, which
every cache hit already takes and every connection on the file shares.
PageCount reads it on each range check - once per row an index seek
fetches - so it added a lock acquisition to the hottest read path. It
is a single value, so it is now read and written atomically without
the lock.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: ChrisJollyAU

src/LibRed/LibRed.Core/IO/PageCache.cs

@@ -40,7 +40,9 @@ private sealed class Entry(int page, byte[] bytes)
     // The file's committed length in bytes, shared like the pages: every change to it is made by a channel on this
     // file, which records it here, so measuring the stream again only repeats this number - at the cost of a
     // file-information syscall per measurement, which on Windows made every pointer range check on a read path
-    // expensive. Seeded by the first channel to open the file; -1 until then.
+    // expensive. Seeded by the first channel to open the file; -1 until then. Read and written without _gate:
+    // every range check reads it, and taking the lock every cache hit already takes would add contention
+    // between all the connections on the file for a single value.
     private long _fileLength = -1;
     private readonly Dictionary<int, LinkedListNode<Entry>> _map = [];
     private readonly LinkedList<Entry> _lru = new(); // first = most-recently-used
@@ -203,24 +205,14 @@ public void MarkSchemaChanged()
     }
 
     /// <summary>The file's committed length in bytes (see <see cref="SetFileLength"/>).</summary>
-    public long FileLength
-    {
-        get { lock (_gate) return _fileLength; }
-    }
+    public long FileLength => Interlocked.Read(ref _fileLength);
 
     /// <summary>Seeds the committed length from the first channel to open the file. A later open keeps the value
     /// already held, which the writes of the channels before it have kept current.</summary>
-    public void InitFileLength(long measured)
-    {
-        lock (_gate)
-            if (_fileLength < 0) _fileLength = measured;
-    }
+    public void InitFileLength(long measured) => Interlocked.CompareExchange(ref _fileLength, measured, -1);
 
     /// <summary>Records a change a channel has just made to the file's length.</summary>
-    public void SetFileLength(long length)
-    {
-        lock (_gate) _fileLength = length;
-    }
+    public void SetFileLength(long length) => Interlocked.Exchange(ref _fileLength, length);
 
     /// <summary>Returns a previously cached higher-layer parse of <paramref name="page"/> (see
     /// <see cref="SetParsed"/>), or false if the page is not resident or has no parse cached.</summary>