perf: Benchmark Rust vs C FFI for ByteArray BEq in Lean

[samuelburnham]

After #15

#15 switched from a C implementation of BEq for Lean ByteArrays (via memcmp) to a Rust implementation (via == for &[u8] slices). We should investigate whether this causes any any perf regression.

cc @arthurpaulino

[arthurpaulino]

I benchmarked == versus a fast implementation using SIMD (written by DeepSeek). This is the criterion code:

#![feature(portable_simd)]

use criterion::{criterion_group, criterion_main, Criterion};
use std::simd::{u8x16, prelude::SimdPartialEq};

fn fast_compare(a: &[u8], b: &[u8]) -> bool {
    if a.len() != b.len() {
        return false;
    }

    let mut i = 0;

    // Compare chunks of 16 bytes using SIMD
    while i + 16 <= a.len() {
        let chunk_a = u8x16::from_slice(&a[i..i + 16]);
        let chunk_b = u8x16::from_slice(&b[i..i + 16]);
        if chunk_a.simd_ne(chunk_b).any() {
            return false;
        }
        i += 16;
    }

    // Compare remaining bytes
    while i < a.len() {
        if a[i] != b[i] {
            return false;
        }
        i += 1;
    }

    true
}

fn bench_compare(c: &mut Criterion) {
    let data1 = &[0u8; 1024];
    let data2 = &[0u8; 1024];

    c.bench_function("native_eq", |b| b.iter(|| data1 == data2));
    c.bench_function("fast_compare", |b| b.iter(|| fast_compare(data1, data2)));
}

criterion_group!(benches, bench_compare);
criterion_main!(benches);

These were the results on my machine:

native_eq               time:   [231.37 ps 231.55 ps 231.81 ps]
fast_compare            time:   [23.184 ns 23.220 ns 23.262 ns]

Since 1 ns = 1000 ps, native_eq is around 100 times faster.