Codebase audit fixes

[codeboost]

Audits done by Fable 5.1 and GPT 6 Astra.

---

Fixes a set of correctness and thread-safety bugs found in a codebase audit, with regression tests for each.

Thread safety

Values read from a database can now be used from any thread. Reads go through one shared read-only handle instead of a per-thread Database, with a per-thread file handle behind a single Core for file-backed databases. Memory databases previously shared the writer's Core across threads unsafely.
Key hashing uses per-thread MessageDigest instances instead of the handle's shared digest, which raced when a read value was passed between threads.
Terminated reader threads no longer retain file descriptors. Per-thread file handles are tracked weakly and all remaining handles are closed when the database is closed. Touching a closed database from a new thread throws IllegalStateException.

Write correctness

A failed key lookup (e.g. an unsupported key type) could leave partial state in the shared digest and corrupt the next write. The digest is now reset even when hashing throws.
Writing a value read from one database into a different database is now refused with IllegalArgumentException. Slots are offsets into the source database's storage, so this silently wrote garbage before. A small registry ties each database's reader and writer handles together so round-tripping within the same database still uses structural sharing. materialize the value to copy it across databases (documented in the README).
Keypath writes to an absent hash-map key stored only the hash, leaving a keyless entry. write-cursor-for-key now stores the key as well.
Keypath writes into hash-set members now throw, matching sorted sets. Set members are immutable keys, so a write through a member cursor filed the value under the wrong hash.
materialize now materializes map keys too, not just values, for hash maps and sorted maps.
v->slot! unwraps XITDB wrapper types before the generic collection branches, so nested wrapped values are written by reference instead of being deep-copied (and sorted maps/sets no longer degrade to hash ones inside collections).
compact gives the compacted copy its own digest instead of sharing the source's.

Other

snapshot-memory-db materializes before writing into the memory database.
unwrap uses an interface check instead of satisfies? on the per-element write path.
Function behaviour is explained in docstrings instead of inline comments.

Tests added: close/file-descriptor lifecycle, cross-database writes, hashing after failed lookups, multi-threaded read sharing, keypath cursor writes, nested wrapped values, and snapshot materialization.

[xeubie]

I updated xitdb-java with a bunch of thread safety fixes. I also was able to remove some of the changes in this branch by moving the functionality into the java library:

• Add CoreReadOnlyFile, replacing xitdb-clj's custom file core and handle management
• Use a separate MessageDigest internally when hashing, replacing xitdb-clj's digest cache, manual resets, and compaction digest workaround

The last commit is optional, but it replaces the global db registry with a "db context" that accomplishes the same thing without global state. It allows the writeable database to find its readable equivalent without a global registry. Just thought it would be a good addition so I threw it in.

[xeubie]

See my comment above