Implement safe storage handles

[teh-cmc]

This implements ChunkStoreHandle & QueryCacheHandle which, among other things, allow for streaming dataframes across FFI and network barriers.

/// A ref-counted, inner-mutable handle to a [`QueryCache`].
///
/// Cheap to clone.
///
/// It is possible to grab the lock behind this handle while _maintaining a static lifetime_, see:
/// * [`QueryCacheHandle::read_arc`]
/// * [`QueryCacheHandle::write_arc`]
#[derive(Clone)]
pub struct QueryCacheHandle(Arc<parking_lot::RwLock<QueryCache>>);

/// A ref-counted, inner-mutable handle to a [`ChunkStore`].
///
/// Cheap to clone.
///
/// It is possible to grab the lock behind this handle while _maintaining a static lifetime_, see:
/// * [`ChunkStoreHandle::read_arc`]
/// * [`ChunkStoreHandle::write_arc`]
#[derive(Clone)]
pub struct ChunkStoreHandle(Arc<parking_lot::RwLock<ChunkStore>>);

Those handles on their own are extremely problematic though: letting them loose all across the codebase effectively wraps the entire codebase in a semantically-unsafe{} block where every row interacting with these handles can lead to very nasty race conditions and even deadlocks.
That's why this PR also introduces the StorageEngine type, which makes using these handles actually safe in practice:

/// Keeps track of handles towards a [`ChunkStore`] and its [`QueryCache`].
///
/// A [`StorageEngine`] doesn't add any feature on top of what [`ChunkStoreHandle`] and
/// [`QueryCacheHandle`] already offer: the job of the [`StorageEngine`] is to leverage the type
/// system in order to protect against deadlocks and race conditions at compile time.
///
/// The handles stored within will never be publicly accessible past construction.
///
/// The underlying [`ChunkStore`] and [`QueryCache`] can be accessed through one of the
/// following methods:
/// * [`StorageEngine::read`]
/// * [`StorageEngine::read_arc`]
/// * [`StorageEngine::write`]
/// * [`StorageEngine::write_arc`]
#[derive(Clone)]
pub struct StorageEngine {
    store: ChunkStoreHandle,
    cache: QueryCacheHandle,
}

Balancing these safety guarantees with the flexibility we need (today... and tomorrow!) for all our corner use cases has proven to be a subtle art...

• Fixes Introduce cheaply clonable ChunkStoreHandle and QueryCacheHandle #7486

Checklist

• I have read and agree to Contributor Guide and the Code of Conduct
• I've included a screenshot or gif (if applicable)
• I have tested the web demo (if applicable):
  • Using examples from latest main build: rerun.io/viewer
  • Using full set of examples from nightly build: rerun.io/viewer
• The PR title and labels are set such as to maximize their usefulness for the next release's CHANGELOG
• If applicable, add a new check to the release checklist!
• If have noted any breaking changes to the log API in CHANGELOG.md and the migration guide

• PR Build Summary
• Recent benchmark results
• Wasm size tracking

To run all checks from main, comment on the PR with @rerun-bot full-check.

[teh-cmc]

Quickly drafting to check whether there are some remnants from the first four iterations that have made it into the final thing and that could just be removed/simplified now, which is very possible because it's all a big blur at this point 🫠

[teh-cmc]

Quickly drafting to check whether there are some remnants from the first four iterations that have made it into the final thing and that could just be removed/simplified now, which is very possible because it's all a big blur at this point 🫠

Nope, I mostly just ran into differently shaped walls.

[teh-cmc]

🙏

[zehiko]

I learned a lot reviewing this PR and I really appreciate nice documentation! I believe it's clear to me how this addresses use cases like streaming and why the protection is in place, but folks with more experience with the code base I'm sure can provide more valuable feedback.

[zehiko]

perhaps it's worth documenting an example use case of doing the wrong thing without the protection that StorageEngine provides?