chore: Tier 2 quick wins — version skew, docs, cleanup, overflow-safe bounds

- Fix version skew: clawhdf5-py (pyproject.toml 1.93.0 -> 2.1.0) and
  packages/clawhdf5-node (package.json 2.0.0 -> 2.1.0) were both behind
  the actual crate version.
- Correct stale ROADMAP.md claims: the TypeScript bridge already has a
  complete napi-rs package (not "no package.json"); CI/CD is now wired
  up via .gitea/workflows/ci.yml.
- Fix CLAUDE.md: clawhdf5-gpu uses wgpu with hand-written WGSL compute
  shaders, not CubeCL.
- chunked_read.rs: drop 12 unnecessary chunk_dimensions[..rank].to_vec()
  allocations — all three callees already accept &[u32].
- btree_v1.rs: add an overflow-safe ensure_len(data, offset, needed)
  helper (checked_add) and use it at the two plain-arithmetic bounds
  guards, closing a usize-overflow edge case reachable from a crafted
  near-usize::MAX B-tree offset. Add a regression test.
- Clarify that the integrity hashes in clawhdf5-agent/provenance.rs
  (FNV-1a) and clawhdf5-format/provenance.rs (SHA-256) are unkeyed and
  only detect accidental corruption, not tampering — doc-only change.
- README.md: document that the mpi-io feature's read/write paths are
  root-read+broadcast / gather-to-rank-0, not true collective I/O.

crates/clawhdf5-agent/src/provenance.rs

@@ -1,7 +1,9 @@
 //! Memory provenance tracking and integrity verification.
 //!
-//! Records the origin, authorship, and integrity of every memory chunk
-//! so the system can detect tampering and trace data lineage.
+//! Records the origin, authorship, and a content hash of every memory chunk
+//! so the system can detect *accidental* corruption and trace data lineage.
+//! The hash is unkeyed (see [`fnv1a_64`]) — this is not a tamper-evidence or
+//! authenticity guarantee.
 
 use std::collections::HashMap;
 
@@ -11,6 +13,10 @@ pub use crate::consolidation::MemorySource;
 // Hash helper (std-only FNV-1a 64-bit)
 // ---------------------------------------------------------------------------
 
+/// Unkeyed, non-cryptographic FNV-1a hash for detecting accidental content
+/// corruption. It is trivially forgeable by anyone able to modify the stored
+/// data, since they can recompute and overwrite the stored hash alongside
+/// it — do not rely on this as a tamper-evidence or authenticity control.
 fn fnv1a_64(text: &str) -> u64 {
     const OFFSET: u64 = 14_695_981_039_346_656_037;
     const PRIME: u64 = 1_099_511_628_211;
@@ -114,6 +120,11 @@ impl ProvenanceStore {
 
     /// Re-hash `current_chunk` and compare against the stored hash.
     /// Returns `true` if the content matches (integrity intact).
+    ///
+    /// This only detects accidental corruption: the hash is unkeyed, so an
+    /// actor able to modify the stored chunk can also recompute and
+    /// overwrite the stored hash. Do not treat a `true` result as proof the
+    /// data hasn't been tampered with.
     pub fn verify_integrity(&self, record_id: u64, current_chunk: &str) -> bool {
         match self.records.get(&record_id) {
             Some(p) => p.content_hash == fnv1a_64(current_chunk),