aead: split new_test! into new_pass_test! and new_fail_test!

[baloo]

This is #1803 rebased and reworked with the new blobby APIs.

Helper utility to split the blob files:

use blobby::encode_blobs;
use std::{
    env,
    fs::File,
    io::{self, BufReader, BufWriter, Read, Write},
    path::PathBuf,
};

fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().skip(1).collect();

    if args.is_empty() {
        println!(
            "Blobby test vector split utility.\n\
            Usage: split <input blb file>"
        );
        return Ok(());
    }

    let in_path: PathBuf = args[0].clone().into();
    let base = in_path.parent().unwrap();
    let name = in_path.file_name().unwrap().to_str().unwrap();
    let (base_name, ext) = name.rsplit_once(".").unwrap();

    let out_pass_path = base.to_path_buf().join(format!("{base_name}_pass.{ext}"));
    let out_fail_path = base.to_path_buf().join(format!("{base_name}_fail.{ext}"));
    println!("out_pass: {}", out_pass_path.display());
    println!("out_fail: {}", out_fail_path.display());

    let mut in_file = BufReader::new(File::open(in_path)?);
    let mut out_pass_file = BufWriter::new(File::create_new(out_pass_path)?);
    let mut out_fail_file = BufWriter::new(File::create_new(out_fail_path)?);

    let mut data = Vec::new();
    in_file.read_to_end(&mut data)?;
    let res = blobby::parse_into_vec(&data).map_err(|e| {
        io::Error::new(
            io::ErrorKind::InvalidData,
            format!("invalid blobby data: {e:?}"),
        )
    })?;

    let mut data_pass: Vec<&[u8]> = Vec::new();
    let mut data_fail: Vec<&[u8]> = Vec::new();
    for row in res.chunks(6) {
        let [key, nonce, aad, plaintext, ciphertext, pass] = row else {
            panic!("invariant failed")
        };
        if pass[0] == 1 {
            data_pass.extend_from_slice(&[key, nonce, aad, plaintext, ciphertext])
        } else if pass[0] == 0 {
            data_fail.extend_from_slice(&[key, nonce, aad, plaintext, ciphertext])
        } else {
            panic!("invalid data");
        }
    }

    let (data_pass, idx_len) = encode_blobs(&data_pass);
    println!("Pass len: {idx_len:?}");
    out_pass_file.write_all(&data_pass)?;

    let (data_fail, idx_len) = encode_blobs(&data_fail);
    println!("Fail len: {idx_len:?}");
    out_fail_file.write_all(&data_fail)?;

    Ok(())
}

Closes #1803