format: slice entry points for the facade's hot *_in calls (local listing back to main's speed)

Since the M2 merge the facade handed in-memory files to the generic
`*_in` parsers as `&[u8]` (`with_bytes!`), which instantiates them in
the facade crate, where the format crate's private helpers do not
inline without LTO: listing a 400-group v1 file through `File::open`
was 7-10% slower than main. `ObjectHeader::parse_in`,
`group_v2::{resolve_child_in, resolve_group_children_in,
resolve_path_any_in}` and `attribute::{extract_attributes_tolerant_in,
find_attribute_in}` now pass a storage with `as_contiguous()` to their
non-generic slice entry point, compiled once in the format crate; other
storages reach the same generic core as before.

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

crates/clawhdf5-format/src/object_header.rs

@@ -116,25 +116,52 @@ impl ObjectHeader {
     /// Parse an object header at the given offset in the data buffer.
     ///
     /// `offset_size` and `length_size` come from the superblock.
+    #[inline]
     pub fn parse(
         data: &[u8],
         offset: usize,
         offset_size: u8,
         length_size: u8,
     ) -> Result<ObjectHeader, FormatError> {
-        Self::parse_in(data, offset as u64, offset_size, length_size)
+        Self::parse_slice(data, offset as u64, offset_size, length_size)
     }
 
     /// [`Self::parse`] over any [`Storage`].
     ///
     /// Reads the prefix (at most [`V2_PREFIX_MAX`] bytes, signature
     /// included), then each chunk as one bounded read, continuation chunks
-    /// included.
+    /// included. A storage with the whole file in memory is parsed as its
+    /// slice, by code compiled in this crate (see
+    /// [`crate::storage`], "Slice entry points").
+    #[inline]
     pub fn parse_in<S: Storage + ?Sized>(
         file: &S,
         offset: u64,
         offset_size: u8,
         length_size: u8,
+    ) -> Result<ObjectHeader, FormatError> {
+        match file.as_contiguous() {
+            Some(all) => Self::parse_slice(all, offset, offset_size, length_size),
+            None => Self::parse_storage(file, offset, offset_size, length_size),
+        }
+    }
+
+    /// [`Self::parse_storage`] for the slice, compiled in this crate: the
+    /// one copy [`Self::parse`] and [`Self::parse_in`] (in memory) call.
+    fn parse_slice(
+        data: &[u8],
+        offset: u64,
+        offset_size: u8,
+        length_size: u8,
+    ) -> Result<ObjectHeader, FormatError> {
+        Self::parse_storage(data, offset, offset_size, length_size)
+    }
+
+    fn parse_storage<S: Storage + ?Sized>(
+        file: &S,
+        offset: u64,
+        offset_size: u8,
+        length_size: u8,
     ) -> Result<ObjectHeader, FormatError> {
         // The longest prefix of either version, in one read. It holds the
         // whole prefix or ends at the end of the file, so its bounds checks