fix(format): parse HDF5 2.0 native complex datatypes (class 11)

Class 11 (datatype version 5) properties are a single base floating-point
datatype message, not a compound-style member list. The old parser read the
base type's bytes as member names, yielding a garbage datatype, and failed
with UnexpectedEof when a complex type was nested in a compound.

Parse the base type and surface the type as the equivalent {r, i} compound
(the shape h5py writes for numpy complex dtypes), with a size check against
the base type. Covered by byte-level tests taken from HDF5 2.0 output and an
h5py end-to-end test (writer_h5py_tests is now 27/27 against HDF5 2.0.0).

Found while validating a user report of InvalidDatatypeVersion
{ class: 6, version: 5 } against v2.1.0 (already fixed on main in a13ff51,
never released). Add docs/known-issues.md recording that report, this bug,
the open reference-v4 gap and a gpu_tests parallel-run hang; credit the
reporter in the changelog.

Co-Authored-By: Claude Fable 5.1 <[email protected]>

crates/clawhdf5-format/tests/writer_h5py_tests.rs

@@ -292,6 +292,74 @@ f.close()
     assert_eq!(x_vals, vec![1.0, 3.0]);
 }
 
+#[test]
+#[ignore = "requires Python h5py module"]
+fn read_h5py_generated_native_complex() {
+    // HDF5 2.0 native complex (datatype class 11, version 5), written through
+    // h5py's low-level API. Skips when the linked HDF5 predates 2.0.
+    let path = std::env::temp_dir().join("clawhdf5_h5py_native_complex.h5");
+    let gen_script = format!(
+        r#"
+import h5py, numpy as np
+from h5py import h5t, h5s, h5d, h5f, h5p
+if not getattr(h5py.get_config(), 'has_native_complex', False):
+    print('SKIP')
+else:
+    fapl = h5p.create(h5p.FILE_ACCESS)
+    fapl.set_libver_bounds(h5f.LIBVER_LATEST, h5f.LIBVER_LATEST)
+    fid = h5f.create(b'{}', h5f.ACC_TRUNC, fapl=fapl)
+    t = h5t.COMPLEX_IEEE_F64LE
+    d = h5d.create(fid, b'z', t, h5s.create_simple((2,)))
+    d.write(h5s.ALL, h5s.ALL, np.array([1+2j, 3+4j], dtype=np.complex128), mtype=t)
+    fid.close()
+"#,
+        path.display()
+    );
+    if h5py_read(&path, &gen_script) == "SKIP" {
+        eprintln!("HDF5 < 2.0: no native complex support, skipping");
+        return;
+    }
+
+    let bytes = std::fs::read(&path).unwrap();
+    let sig = clawhdf5_format::signature::find_signature(&bytes).unwrap();
+    let sb = clawhdf5_format::superblock::Superblock::parse(&bytes, sig).unwrap();
+    let addr = clawhdf5_format::group_v2::resolve_path_any(&bytes, &sb, "z").unwrap();
+    let hdr = clawhdf5_format::object_header::ObjectHeader::parse(
+        &bytes,
+        addr as usize,
+        sb.offset_size,
+        sb.length_size,
+    )
+    .unwrap();
+    let msg = |t: clawhdf5_format::message_type::MessageType| {
+        &hdr.messages.iter().find(|m| m.msg_type == t).unwrap().data
+    };
+    let (dt, _) = clawhdf5_format::datatype::Datatype::parse(msg(
+        clawhdf5_format::message_type::MessageType::Datatype,
+    ))
+    .unwrap();
+    let ds = clawhdf5_format::dataspace::Dataspace::parse(
+        msg(clawhdf5_format::message_type::MessageType::Dataspace),
+        sb.length_size,
+    )
+    .unwrap();
+    let dl = clawhdf5_format::data_layout::DataLayout::parse(
+        msg(clawhdf5_format::message_type::MessageType::DataLayout),
+        sb.offset_size,
+        sb.length_size,
+    )
+    .unwrap();
+    let raw = clawhdf5_format::data_read::read_raw_data(&bytes, &dl, &ds, &dt).unwrap();
+    let fields = clawhdf5_format::data_read::read_compound_fields(&raw, &dt).unwrap();
+    assert_eq!(fields.len(), 2);
+    let re =
+        clawhdf5_format::data_read::read_as_f64(&fields[0].raw_data, &fields[0].datatype).unwrap();
+    let im =
+        clawhdf5_format::data_read::read_as_f64(&fields[1].raw_data, &fields[1].datatype).unwrap();
+    assert_eq!((fields[0].name.as_str(), re), ("r", vec![1.0, 3.0]));
+    assert_eq!((fields[1].name.as_str(), im), ("i", vec![2.0, 4.0]));
+}
+
 #[test]
 #[ignore = "requires Python h5py module"]
 fn read_h5py_generated_enum() {