[Rust] Capability based DbContext (#5307)

# Description of Changes
An evolution of #4707
where i explored adding a `db_read_only` method to `DbContext`. (hence i
would appreciate your thoughts @gefjon )
This was the wrong appraoch in retrospect because there are still some
annoyances with this.
Furthermore there is really no benefit to adding the associated type
`DbView` and is just making the ergonomics worse.

So here is the new approach which solved all my problems:
Making a trait for every capability which the various contexts are
providing because the Databse is only one of them.
These capabilities are (and pretty much the whole relevant div for this
pr because the impl blocks are trivial) and should be self explanatory:
```rust
pub trait CtxDbRead {
    fn db_read_only(&self) -> &LocalReadOnly;
}
pub trait CtxDbWrite: CtxDbRead {
    fn db(&self) -> &Local;
}
pub trait CtxWithSender {
    fn sender(&self) -> Identity;
}
pub trait CtxWithTimestamp {
    fn timestamp(&self) -> Timestamp;
}
pub trait CtxWithHttp {
    fn http(&self) -> &HttpClient;
}
```
## Why is this relevant?
Lets look at an example building on the previous pr:
You have abstracted your code in a trait which you can call for every
context e.g. authorization.
Now this does not work because the sender method is not available on
`DbContext`.
```rust
impl<Db: CtxDbRead> Authorization for Db {
  fn test(&self,args:Args) {
   self.db_read_only().do_i_have_perms().find(self.sender()); //ERROR: no sender method
}
```
Now this is really annoying since you now have to pass additional
parameters to the method.
Instead we can now specific these capabilities in the type system:
```rust
impl<Db: CtxDbRead+CtxWithSender> Authorization for Db {
  fn test(&self,args:Args) {
   self.db_read_only().do_i_have_perms().find(self.sender()); //WORKS NOW YAY
}
```

Additonally there could be also a `+ CtxWithTimestamp` if you wanted to
for example store a last logged in date or smth (you get the idea)
Now this is far better because `.sender` is available for `ViewContext`
for example so you can authorize with the same method.

## Alternatives/Bikeshedding
I chose the names CtxWith because really the `Contexts` are the common
denominator and not the `Database`.
Thats also the reason why its `CtxDbRead` because you are expressing:
"All context where i get read access to the databse (e.g. everything).
Other names have felt worse.

Also the deprecation can be removed but i think this approach is
strictly superior and i dont think there are currently many people
relying on it.

# API and ABI breaking changes

None. one deprecation for the old `DbContext` but this can also be
removed if desired.

# Expected complexity level and risk
1. Additive change with extremly minimal surface


# Testing
- [x] Works for my project

---------

Signed-off-by: Kilian Strunz <93079615+kistz@users.noreply.github.com>
Co-authored-by: Phoebe Goldman <phoebe@goldman-tribe.org>

Author: kistz

crates/bindings/src/http.rs

@@ -13,7 +13,7 @@ use crate::StdbRng;
 #[cfg(feature = "unstable")]
 use crate::{try_with_tx, with_tx, Timestamp, TxContext};
 use bytes::Bytes;
-#[cfg(all(feature = "rand", feature = "unstable"))]
+#[cfg(all(feature = "rand08", feature = "unstable"))]
 use rand08::RngCore;
 #[cfg(feature = "unstable")]
 use spacetimedb_lib::db::raw_def::v10::MethodOrAny;
@@ -22,10 +22,10 @@ use spacetimedb_lib::http as st_http;
 use spacetimedb_lib::http::{character_is_acceptable_for_route_path, ACCEPTABLE_ROUTE_PATH_CHARS_HUMAN_DESCRIPTION};
 #[cfg(feature = "unstable")]
 use spacetimedb_lib::Identity;
-#[cfg(all(feature = "unstable", feature = "rand"))]
+#[cfg(all(feature = "unstable", feature = "rand08"))]
 use spacetimedb_lib::Uuid;
 use spacetimedb_lib::{bsatn, TimeDuration};
-#[cfg(all(feature = "unstable", feature = "rand"))]
+#[cfg(all(feature = "unstable", feature = "rand08"))]
 use std::cell::Cell;
 #[cfg(all(feature = "unstable", feature = "rand08"))]
 use std::cell::OnceCell;
@@ -72,7 +72,7 @@ pub use spacetimedb_bindings_macro::http_handler as handler;
 
 /// Register a [`Router`](struct@Router) to route HTTP requests to handlers.
 ///
-/// This should annotate a function of no arguments which returns a [`Router`](struct@router).
+/// This should annotate a function of no arguments which returns a [`Router`](struct@Router).
 ///
 /// ```no_run
 /// # use spacetimedb::http::{handler, router, Request, Response, Body, HandlerContext, Router};
@@ -109,7 +109,7 @@ pub struct HandlerContext {
 
     /// A counter used for generating UUIDv7 values.
     /// **Note:** must be 0..=u32::MAX
-    #[cfg(feature = "rand")]
+    #[cfg(feature = "rand08")]
     pub(crate) counter_uuid: Cell<u32>,
 }
 
@@ -121,7 +121,7 @@ impl HandlerContext {
             http: HttpClient {},
             #[cfg(feature = "rand08")]
             rng: OnceCell::new(),
-            #[cfg(feature = "rand")]
+            #[cfg(feature = "rand08")]
             counter_uuid: Cell::new(0),
         }
     }
@@ -148,15 +148,15 @@ impl HandlerContext {
     }
 
     /// Create a new random [`Uuid`] `v4` using the built-in RNG.
-    #[cfg(feature = "rand")]
+    #[cfg(feature = "rand08")]
     pub fn new_uuid_v4(&self) -> anyhow::Result<Uuid> {
         let mut bytes = [0u8; 16];
         self.rng().try_fill_bytes(&mut bytes)?;
         Ok(Uuid::from_random_bytes_v4(bytes))
     }
 
     /// Create a new sortable [`Uuid`] `v7` using the built-in RNG, counter and timestamp.
-    #[cfg(feature = "rand")]
+    #[cfg(feature = "rand08")]
     pub fn new_uuid_v7(&self) -> anyhow::Result<Uuid> {
         let mut random_bytes = [0u8; 4];
         self.rng().try_fill_bytes(&mut random_bytes)?;