edit: dense attributes, compact-to-dense transition, creation order

FileEditor::set_attr now handles every attribute storage libhdf5 uses
for version-2 object headers:

- objects that track (and index) attribute creation order: compact
  attributes carry their creation index in the message header, the
  Attribute Info message its maximum;
- the move to dense storage when an object reaches its compact limit (or
  an attribute is too large for a header message), as H5O__attr_create
  does it: a new fractal heap, name index (v2 B-tree type 8) and, when
  creation order is indexed, creation-order index (type 9); the compact
  attributes moved over in header message order, their messages freed;
- objects already in dense storage (h5py- or clawhdf5-written): new
  attributes inserted (H5A__dense_insert), an attribute replaced by one of
  the same encoded size rewritten in its heap object (H5A__dense_write),
  otherwise removed from both indexes and the heap and inserted anew.

edit/fheap.rs follows H5HF: managed objects go to the best-fitting free
section of the heap's free-space manager (FSHD/FSSE, kept as libhdf5
keeps it — sorted sections, counts, section info reallocated when its
size changes, the manager deleted when empty); otherwise to a new direct
block: the root direct block of an empty heap, else the block at the
allocation iterator in the root indirect block (created from the root
direct block, doubled as needed), with libhdf5's managed-space, allocated
space, free space and iterator bookkeeping. Objects above the managed
limit are huge objects in their own space, indexed by the huge-object
B-tree (type 1). Removed objects return their space merged with adjacent
free space. Refused before anything is written: heaps with I/O filters,
child indirect blocks, an object larger than the next heap block
(libhdf5 skips blocks and records them as free space), free sections
other than those inside direct blocks, removing a direct block's last
object (libhdf5 frees the block), directly addressed huge objects.

Attributes are encoded as libhdf5 does when h5py opens a file r+ (low
bound "earliest"): message version 1 (3 for non-ASCII names), simple
dataspaces with their maximum dimensions. Header chunks are now visited
in libhdf5's order (FIFO), which is also the order attributes move to
dense storage in.

Tests (edit_coverage_interop): 40 attributes on each of a plain group, a
group tracking and indexing creation order, and a dataset (earliest,
v110, latest), some above the 4 KiB managed limit, then same-size
rewrites: the heap statistics, free-space sections and both index
B-trees node for node equal libhdf5's doing the same through h5py; then
replacements of other sizes, h5py adds/deletes/rewrites; h5py, h5dump,
h5rs check and our reader agree throughout, h5py's attribute count
included. clawhdf5-written dense storage (tracked and untracked) is
extended the same way; refusals leave the file byte for byte as it was.
edit_interop's attribute test now expects dense storage and tracked
creation order to work.

Co-Authored-By: Claude Opus 5.5 (1M context) <[email protected]>

crates/clawhdf5-tools/tests/edit_interop.rs

@@ -836,19 +836,16 @@ fn attributes_in_place() {
             .unwrap();
         want.push(("d", "units".into(), AttrValue::String("km".into())));
         if *lv != "'earliest'" {
-            // Up to the compact limit (8) and no further; attributes in
-            // dense storage and tracked creation order are refused, and a
-            // refused edit writes nothing.
+            // Up to the compact limit (8), then into dense storage; objects
+            // already in dense storage and ones tracking creation order.
             ed.set_attr("g", "eighth", &AttrValue::I64(8)).unwrap();
             want.push(("g", "eighth".into(), AttrValue::I64(8)));
-            let before = std::fs::read(&path).unwrap();
-            unsupported(ed.set_attr("g", "ninth", &AttrValue::I64(9)));
-            unsupported(ed.set_attr("dense", "k0", &AttrValue::I64(1)));
-            unsupported(ed.set_attr("tracked", "b", &AttrValue::I64(1)));
-            assert!(
-                std::fs::read(&path).unwrap() == before,
-                "a refused edit changed the file"
-            );
+            ed.set_attr("g", "ninth", &AttrValue::I64(9)).unwrap();
+            want.push(("g", "ninth".into(), AttrValue::I64(9)));
+            ed.set_attr("dense", "k0", &AttrValue::I64(1)).unwrap();
+            want.push(("dense", "k0".into(), AttrValue::I64(1)));
+            ed.set_attr("tracked", "b", &AttrValue::I64(1)).unwrap();
+            want.push(("tracked", "b".into(), AttrValue::I64(1)));
         }
         drop(ed);
         check_tools(&path, *dump);