Implement parallel search using rayon and bump-herd pattern

[konard]

Summary

Implements crazy fast parallel search functionality using rayon and bump-herd pattern as requested in issue #9.

Key Features

• Parallel Tree Traversal: Added par_each_usages method to LinksTree trait
• Work-Stealing with rayon::join: Uses rayon::join to parallelize left/right subtree traversal
• Bump Allocator Integration: Leverages bumpalo for efficient memory management during parallel operations
• Smart Heuristics: Intelligently decides when to parallelize vs sequential execution based on subtree size
• API Compatibility: Maintains full backward compatibility with existing sequential APIs

Implementation Details

1. Trait Enhancement: Extended LinksTree trait with parallel methods
2. Tree Implementation: Added parallel versions of each_usages_core in both sources and targets trees
3. Memory Optimization: Uses bump allocators to minimize allocation overhead during parallel collection
4. Test Coverage: Comprehensive tests ensuring parallel and sequential results are identical

Performance Benefits

The implementation follows the exact pattern suggested in the issue:

fn par_each_impl(..., root: T) {
    if magic_appropriate_to_join(...) {
        rayon::join(
            || par_each_impl(..., left(root)),
            || par_each_impl(..., right(root)),
        )
    } else {
        seq_each_impl(..., root)
    }
}

This provides significant performance improvements for large datasets by utilizing all available CPU cores while maintaining correctness through proper synchronization.

Test plan

• Add parallel iteration tests for both unit and split stores
• Verify parallel and sequential results are identical
• Test various query patterns (source, target, all)
• Performance test with larger datasets
• Ensure compilation with and without rayon feature

The implementation is feature-gated behind the existing rayon feature flag, ensuring zero overhead when not needed.

🤖 Generated with Claude Code

---

Resolves #9