Split benchmark files into separate neo4j/ and doublets/ directories

Per user feedback, reorganize benchmarks to have clear separation between
Neo4j and Doublets implementations. Each file now contains only one
database's benchmarks for easy side-by-side comparison.

New structure:
- rust/benches/benchmarks/neo4j/     - All Neo4j benchmarks
- rust/benches/benchmarks/doublets/  - All Doublets benchmarks

Each directory has the same structure:
- create.rs, update.rs, delete.rs - CRUD operations
- each/all.rs, identity.rs, concrete.rs, outgoing.rs, incoming.rs - Query operations

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[email protected]>

Author: konard

rust/benches/bench.rs

@@ -1,8 +1,12 @@
 #![feature(allocator_api)]
 
 use benchmarks::{
-    create_links, delete_links, each_all, each_concrete, each_identity, each_incoming,
-    each_outgoing, update_links,
+    // Neo4j benchmarks
+    neo4j_create_links, neo4j_delete_links, neo4j_each_all, neo4j_each_concrete,
+    neo4j_each_identity, neo4j_each_incoming, neo4j_each_outgoing, neo4j_update_links,
+    // Doublets benchmarks
+    doublets_create_links, doublets_delete_links, doublets_each_all, doublets_each_concrete,
+    doublets_each_identity, doublets_each_incoming, doublets_each_outgoing, doublets_update_links,
 };
 use criterion::{criterion_group, criterion_main};
 
@@ -18,15 +22,30 @@ macro_rules! tri {
 
 pub(crate) use tri;
 
+// Neo4j benchmarks group
 criterion_group!(
-    benches,
-    create_links,
-    delete_links,
-    each_identity,
-    each_concrete,
-    each_outgoing,
-    each_incoming,
-    each_all,
-    update_links
+    neo4j_benches,
+    neo4j_create_links,
+    neo4j_delete_links,
+    neo4j_each_identity,
+    neo4j_each_concrete,
+    neo4j_each_outgoing,
+    neo4j_each_incoming,
+    neo4j_each_all,
+    neo4j_update_links
 );
-criterion_main!(benches);
+
+// Doublets benchmarks group
+criterion_group!(
+    doublets_benches,
+    doublets_create_links,
+    doublets_delete_links,
+    doublets_each_identity,
+    doublets_each_concrete,
+    doublets_each_outgoing,
+    doublets_each_incoming,
+    doublets_each_all,
+    doublets_update_links
+);
+
+criterion_main!(neo4j_benches, doublets_benches);

rust/benches/benchmarks/create.rs

@@ -0,0 +1,78 @@
+//! # Doublets Create Links Benchmark
+//!
+//! This benchmark measures the performance of creating new links in Doublets.
+//!
+//! ## Implementation
+//!
+//! Doublets creates links by:
+//! - Allocating next available ID from internal counter
+//! - Writing (id, id, id) tuple directly to memory/file
+//! - Updating source and target indexes
+//! - Time complexity: O(log n) for index updates
+
+use std::{
+    alloc::Global,
+    time::{Duration, Instant},
+};
+
+use criterion::{measurement::WallTime, BenchmarkGroup, Criterion};
+use doublets::{
+    mem::{Alloc, FileMapped},
+    parts::LinkPart,
+    split::{self, DataPart, IndexPart},
+    unit, Doublets,
+};
+use linksneo4j::{bench, Benched, Fork, LINK_COUNT};
+
+use crate::tri;
+
+/// Runs the create benchmark on a Doublets backend.
+fn bench<B: Benched + Doublets<usize>>(
+    group: &mut BenchmarkGroup<WallTime>,
+    id: &str,
+    mut benched: B,
+) {
+    group.bench_function(id, |bencher| {
+        bench!(|fork| as B {
+            for _ in 0..*LINK_COUNT {
+                let _ = elapsed! {fork.create_point()?};
+            }
+        })(bencher, &mut benched);
+    });
+}
+
+/// Creates benchmark for Doublets backends on link creation.
+pub fn create_links(c: &mut Criterion) {
+    let mut group = c.benchmark_group("Create");
+
+    tri! {
+        bench(
+            &mut group,
+            "Doublets_United_Volatile",
+            unit::Store::<usize, Alloc<LinkPart<_>, Global>>::setup(()).unwrap()
+        )
+    }
+    tri! {
+        bench(
+            &mut group,
+            "Doublets_United_NonVolatile",
+            unit::Store::<usize, FileMapped<LinkPart<_>>>::setup("united.links").unwrap()
+        )
+    }
+    tri! {
+        bench(
+            &mut group,
+            "Doublets_Split_Volatile",
+            split::Store::<usize, Alloc<DataPart<_>, _>, Alloc<IndexPart<_>, _>>::setup(()).unwrap()
+        )
+    }
+    tri! {
+        bench(
+            &mut group,
+            "Doublets_Split_NonVolatile",
+            split::Store::<usize, FileMapped<_>, FileMapped<_>>::setup(("split_index.links", "split_data.links")).unwrap()
+        )
+    }
+
+    group.finish();
+}