Read, write and verify PLXI packs.

    // `write` returns the whole pack as bytes. No file is touched.
    let bytes = write(&records, None)?;

    // Opening verifies the pack by default (digest, header, record count).
    let pack = Pack::from_bytes(bytes, OpenOptions::default())?;
    assert_eq!(pack.record_count(), 3);
    assert!(!pack.has_appendix());

    // Records come back in the format's sort order (entities before
    // relations), spelled the way the writer emits them.
    let out: Vec<String> = pack
        .records()
        .map(|r| r.map(|rec| rec.json_line().to_string()))
        .collect::<Result<_, _>>()?;
    assert_eq!(
        out,
        [
            concat!(
                r#"{"k":"ent","v":1,"id":"e1","t":"Person","#,
                r#""name":"Ada","salience":0.5,"stub":false}"#
            ),
            r#"{"k":"ent","v":1,"id":"e2","t":"Person","stub":false}"#,
            r#"{"k":"rel","v":1,"src":"e1","tgt":"e2","kind":"knows"}"#,
        ]
    );
    for line in &out {
        println!("{line}");
    }
    println!("sha256 = {}", pack.sha256_hex());

    // Keep a copy on disk, for checking with standard tools.
    std::fs::write("sample.plxi", pack.to_bytes())?;
    println!("wrote sample.plxi, {} bytes", pack.to_bytes().len());

    // Change one letter in the record text after the pack was sealed:
    // "Person" becomes "person". The JSON is still valid; the digest
    // no longer matches.
    let mut damaged = good;
    let at = damaged
        .windows(6)
        .position(|w| w == b"Person")
        .expect("the record text contains \"Person\"");
    damaged[at] = b'p';

    // The default open refuses it and names the reason.
    let err = Pack::from_bytes(damaged.clone(), OpenOptions::default())
        .unwrap_err();
    assert_eq!(err.kind(), ErrorKind::ChecksumMismatch);
    assert_eq!(err.kind().as_str(), "checksum_mismatch");
    println!("refused: {err}");