More granular table traits (#4775)

# Description of Changes

Refactored the Rust SDK table trait surface into composable capabilities
and updated Rust codegen to match. [Discord
thread](https://discord.com/channels/1037340874172014652/1492137984902959164)

### Motivation

The granular traits are a useful type-system cleanup on their own, but
the main motivation is to let downstream integration crates like
[bevy_stdb](https://github.com/onx2/bevy_stdb) express callback
capabilities more directly instead of routing them through broader
semantic categories.

For example, `bevy_stdb` may want to support bindings like “forward only
inserts from this subscribed view as Bevy messages” for a relation that
is not semantically an `EventTable`. Today this can still be made to
work with broader abstractions, so this is not primarily about enabling
new runtime behavior. The value is mostly at compile time: more precise
trait bounds, clearer downstream APIs, and better guarantees that a
binding only requires the capabilities it actually uses.

Concretely, this makes it easier for integration crates to model things
like insert-only or delete-only bindings for ordinary tables or views
without conflating those behaviors with `EventTable` semantics.

Example:

```rust
// Current semantic shape:
plugin.add_event_table::<LogRow>(|reg, db| reg.bind(db.logs()));

// Potential capability-based shape:
plugin.add_insert_source::<CharacterRow>(|reg, db| reg.bind(db.characters_near_me()));
plugin.add_delete_source::<CharacterRow>(|reg, db| reg.bind(db.characters_near_me()));
```

### Summary
- Added a shared `TableLike` trait for common table handle
functionality:
  - `Row`
  - `EventContext`
  - `count`
  - `iter`
- Added capability traits:
  - `WithInsert`
  - `WithDelete`
  - `WithUpdate`

# API and ABI breaking changes

None. This is additive only.

# Expected complexity level and risk

2/5

This is additive but potential risks/complexity are that the surface
area of the API is larger and there isn't really overlap between
original approach and the additive. So maybe in usage we'll need to
consider satisfying those new traits too?

# Testing

- [x] Ran `cargo check --manifest-path
/Users/onx2/Documents/projects/SpacetimeDB/sdks/rust/Cargo.toml`
- [x] Ran `cargo test --manifest-path
/Users/onx2/Documents/projects/SpacetimeDB/Cargo.toml -p
spacetimedb-codegen test_codegen_rust`
- [x] Regenerated Rust client bindings using the workspace CLI and
verified generated impls match the new trait structure
- [ ] Reviewer: regenerate a Rust client with the workspace CLI and
confirm the generated bindings compile cleanly

---------

Co-authored-by: Zeke Foppa <196249+bfops@users.noreply.github.com>
Co-authored-by: clockwork-labs-bot <clockwork-labs-bot@users.noreply.github.com>

Author: 3 people

crates/bindings-typescript/case-conversion-test-client/src/module_bindings/index.ts

@@ -183,6 +183,14 @@ pub struct {insert_callback_id}(__sdk::CallbackId);
             write!(
                 out,
                 "
+impl<'ctx> __sdk::TableLike for {table_handle}<'ctx> {{
+    type Row = {row_type};
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {{ self.imp.count() }}
+    fn iter(&self) -> impl Iterator<Item = {row_type}> + '_ {{ self.imp.iter() }}
+}}
+
 impl<'ctx> __sdk::EventTable for {table_handle}<'ctx> {{
     type Row = {row_type};
     type EventContext = super::EventContext;
@@ -203,6 +211,21 @@ impl<'ctx> __sdk::EventTable for {table_handle}<'ctx> {{
         self.imp.remove_on_insert(callback.0)
     }}
 }}
+
+impl<'ctx> __sdk::WithInsert for {table_handle}<'ctx> {{
+    type InsertCallbackId = {insert_callback_id};
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> {insert_callback_id} {{
+        {insert_callback_id}(self.imp.on_insert(Box::new(callback)))
+    }}
+
+    fn remove_on_insert(&self, callback: {insert_callback_id}) {{
+        self.imp.remove_on_insert(callback.0)
+    }}
+}}
 "
             );
         } else {
@@ -213,6 +236,14 @@ impl<'ctx> __sdk::EventTable for {table_handle}<'ctx> {{
                 out,
                 "pub struct {delete_callback_id}(__sdk::CallbackId);
 
+impl<'ctx> __sdk::TableLike for {table_handle}<'ctx> {{
+    type Row = {row_type};
+    type EventContext = super::EventContext;
+
+    fn count(&self) -> u64 {{ self.imp.count() }}
+    fn iter(&self) -> impl Iterator<Item = {row_type}> + '_ {{ self.imp.iter() }}
+}}
+
 impl<'ctx> __sdk::Table for {table_handle}<'ctx> {{
     type Row = {row_type};
     type EventContext = super::EventContext;
@@ -246,6 +277,36 @@ impl<'ctx> __sdk::Table for {table_handle}<'ctx> {{
         self.imp.remove_on_delete(callback.0)
     }}
 }}
+
+impl<'ctx> __sdk::WithInsert for {table_handle}<'ctx> {{
+    type InsertCallbackId = {insert_callback_id};
+
+    fn on_insert(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> {insert_callback_id} {{
+        {insert_callback_id}(self.imp.on_insert(Box::new(callback)))
+    }}
+
+    fn remove_on_insert(&self, callback: {insert_callback_id}) {{
+        self.imp.remove_on_insert(callback.0)
+    }}
+}}
+
+impl<'ctx> __sdk::WithDelete for {table_handle}<'ctx> {{
+    type DeleteCallbackId = {delete_callback_id};
+
+    fn on_delete(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row) + Send + 'static,
+    ) -> {delete_callback_id} {{
+        {delete_callback_id}(self.imp.on_delete(Box::new(callback)))
+    }}
+
+    fn remove_on_delete(&self, callback: {delete_callback_id}) {{
+        self.imp.remove_on_delete(callback.0)
+    }}
+}}
 "
             );
 
@@ -272,6 +333,21 @@ impl<'ctx> __sdk::TableWithPrimaryKey for {table_handle}<'ctx> {{
         self.imp.remove_on_update(callback.0)
     }}
 }}
+
+impl<'ctx> __sdk::WithUpdate for {table_handle}<'ctx> {{
+    type UpdateCallbackId = {update_callback_id};
+
+    fn on_update(
+        &self,
+        callback: impl FnMut(&Self::EventContext, &Self::Row, &Self::Row) + Send + 'static,
+    ) -> {update_callback_id} {{
+        {update_callback_id}(self.imp.on_update(Box::new(callback)))
+    }}
+
+    fn remove_on_update(&self, callback: {update_callback_id}) {{
+        self.imp.remove_on_update(callback.0)
+    }}
+}}
 "
                 );
             }