fix(engine): keep shared files open when a caller's thread is interrupted

[venkat1701]

Closes #86.

Why

The JDK closes a FileChannel for every thread when one thread is interrupted during I/O on it. The engine shares its channels between threads, so one interrupted commit closed the write-ahead log. After that, every commit and the shutdown checkpoint failed until the process restarted. Segment files, the change feed, pages.dir and pages.ref had the same problem.

What changes

• page/FileHandle wraps a channel that several threads share:
  • It clears the caller's interrupt flag for the call and sets it again afterwards, so the caller still sees its interrupt.
  • If the channel was closed anyway, it reopens the file and runs the call again. That covers an interrupt arriving in the middle of the call, or an interrupt on another thread. Every call is positional, so running it again reads or writes the same bytes.
  • Once the handle itself is closed, it stays closed.
• Shared channels:
  • SegmentFile and MappedLongs (behind pages.dir and pages.ref) use it.
  • So do the active write-ahead log segment and the change feed's segments.
• Checkpoints and shutdown:
  • A checkpoint runs with the caller's interrupt flag cleared, since it also writes short-lived files (the catalog, the reference journal).
  • Shutdown does the same. Before, join on the maintenance thread returned straight away on an interrupted thread, so shutdown could close files while maintenance was still using them.
• docs/storage/pages.md explains all this.

The WAL reader that recovery uses keeps its own channel per reader. An interrupt there only fails that reader, which is what an interrupt should do.

Testing

• Full suite: 157 tests pass, and each commit builds and passes on its own.
• FileHandleTest:
  • a flag that was set beforehand;
  • an interrupt in the middle of a call;
  • a channel closed by another thread;
  • a closed handle.
• PageStoreTest: an interrupted thread writes, reads and syncs pages in the growing segment, then another thread keeps using the same segment.
• PageDirectoryTest: an interrupted thread grows the directory past its first 8 MiB chunk.
• InterruptTest:
  • commits, reads, replays the feed and checkpoints from an interrupted thread;
  • then commits 200 times from another thread;
  • then closes from an interrupted thread, reopens, and checks the data and the reference counts.
• Each test catches its bug: I put each changed file back to its version on main, one at a time: SegmentFile, MappedLongs, WriteAheadLog, ChangeFeed and Checkpointer. Every time, at least one of the new tests fails.
• Not covered by a test: the shutdown change. With it reverted, close still succeeds in the test, because the maintenance thread happens to be idle.
• Native image: the build passes, and:
  • after loading examples/clinical-claims.hql, hstore check verifies 105 pages and the reference counts match;
  • after a SIGKILL partway through a 20,000-insert load, reopening replays 467 commits and the counts match;
  • COMPACT; runs and check passes afterwards.