chore: consolidate Rust and C++ API

[nyurik]

• split all API into cleanly defined "block" api and "variable length" api. The API forces the input to be blocks of constant size, at compile time, and for the codec to actually match that.
• Made code shorter by a thousand lines
• Identical C++ and Rust usage
• Introduce a new Composite codec that requires a generic BlockCodec and AnyLenCodec

pub trait BlockCodec {
    /// The fixed-size block type.  Must be plain-old-data (`Pod`).
    /// In practice this will be `[u32; 128]` or `[u32; 256]`.
    type Block: Pod;

    /// Compress a slice of complete, fixed-size blocks.
    ///
    /// No remainder is possible — the caller must split the input first using
    /// [`slice_to_blocks`] and handle any remainder separately.
    fn encode_blocks(
        &mut self,
        blocks: &[Self::Block],
        out: &mut Vec<u32>,
    ) -> Result<(), FastPForError>;

    /// Decompress exactly `n_blocks` blocks from `input`.
    fn decode_blocks(
        &mut self,
        input: &[u32],
        n_blocks: usize,
        out: &mut Vec<u32>,
    ) -> Result<(), FastPForError>;
}

/// Compresses and decompresses an arbitrary-length `&[u32]` slice.
pub trait AnyLenCodec {
    /// Compress an arbitrary-length slice of `u32` values.
    fn encode(&mut self, input: &[u32], out: &mut Vec<u32>) -> Result<(), FastPForError>;

    /// Decompress a previously compressed slice of `u32` values.
    fn decode(&mut self, input: &[u32], out: &mut Vec<u32>) -> Result<(), FastPForError>;
}

/// Split a flat `&[u32]` into `(&[Blocks::Block], &[u32])` without copying.
///
/// # Example
///
/// ```rust,ignore
/// let data: Vec<u32> = (0..600).collect(); // 2 × 256 + 88 remainder
/// let (blocks, remainder) = slice_to_blocks::<FastPFor256>(&data);
/// assert_eq!(blocks.len(), 2);    // 2 blocks of [u32; 256]
/// assert_eq!(remainder.len(), 88);
/// ```
#[must_use]
pub fn slice_to_blocks<Blocks: BlockCodec>(input: &[u32]) -> (&[Blocks::Block], &[u32]) { ... }

/// Combines a block-oriented codec with an arbitrary-length tail codec.
///
/// `CompositeCodec<Blocks, Tail>` implements [`AnyLenCodec`]: it accepts any
/// input length, encodes the aligned prefix with `Blocks`, and the
/// sub-block remainder with `Tail`.
///
/// # Wire format
///
/// ```text
/// [ n_blocks: u32 ] [ Blocks encoded data... ] [ Tail encoded data... ]
/// ```
///
/// # Example
///
/// ```rust,ignore
/// use fastpfor::{AnyLenCodec, FastPFor256WithVByte};
///
/// let data: Vec<u32> = (0..600).collect(); // 2 × 256 + 88 remainder
/// let codec = FastPFor256WithVByte::default();
///
/// let mut encoded = Vec::new();
/// codec.encode(&data, &mut encoded).unwrap();
///
/// let mut decoded = Vec::new();
/// codec.decode(&encoded, &mut decoded).unwrap();
/// assert_eq!(decoded, data);
/// ```
pub struct CompositeCodec<Blocks: BlockCodec, Tail: AnyLenCodec> {...}

[codecov]

Codecov Report

❌ Patch coverage is 76.95783% with 153 lines in your changes missing coverage. Please review.

Files with missing lines	Patch %	Lines
src/test_utils.rs	34.71%	123 Missing and 3 partials ⚠️
src/rust/integer_compression/fastpfor.rs	91.19%	13 Missing and 4 partials ⚠️
src/rust/integer_compression/variable_byte.rs	96.29%	2 Missing and 3 partials ⚠️
src/rust/composite.rs	96.84%	0 Missing and 3 partials ⚠️
src/cpp/wrappers.rs	88.88%	0 Missing and 1 partial ⚠️
src/rust/integer_compression/just_copy.rs	94.11%	0 Missing and 1 partial ⚠️

📢 Thoughts on this report? Let us know!

[CommanderStorm]

LGTM

Performance is also the same

[Copilot]

Pull request overview

Copilot reviewed 47 out of 47 changed files in this pull request and generated 6 comments.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.

[Copilot]

The directory handling in this loop looks incorrect: cd "$dir" is not paired with a reliable cd back to the original directory, and the .git check uses -f even though .git is typically a directory. Consider using pushd/popd, saving root=$(pwd) and cd "$root" each iteration, or checking [ -d .git ] if you want to detect the repo root.

[Copilot]

Spelling typo in comment: “decodeed values” → “decoded values”.

Suggested change

	# Run decode_oracle (parallel Rust + C++ roundtrips, cross-checks decodeed values)
	# Run decode_oracle (parallel Rust + C++ roundtrips, cross-checks decoded values)

[Copilot]

The docs here refer to an existing compress_oracle target, but this PR renames/introduces encode_oracle as the Rust self-roundtrip target. Updating the target name in this comment would keep the fuzz target documentation accurate.

Suggested change

	//! The existing `compress_oracle` target only feeds *well-formed* data to the Rust
	//! The existing `encode_oracle` target only feeds *well-formed* data to the Rust

[Copilot]

The module name in these docs is inconsistent with how this file is actually included. The consumers in this PR use mod test_utils (and lib.rs declares mod test_utils), but the bullets here say mod bench_utils, which is misleading for contributors.

[Copilot]

This comment appears incorrect: DEFAULT_PAGE_SIZE is expressed in number of integers (u32s), so 65,536 corresponds to 256 KiB of u32 data, not “64 KiB / 4 bytes = 16 Ki integers”. Consider rewording to avoid mixing bytes and element counts.

[Copilot]

The comment says sub-block-sized inputs produce no output via BlockCodec, but the current block format always emits at least the length header (e.g. [0] for zero blocks). Consider updating the comment to match the actual behavior being tested (zero aligned blocks rather than “no output”).