Rework networking code and serialization

Tests aren't passing yet, but I need to wind down for the night.

Decide to try out `serde_bare`.

From GPT: `serde_bare` is a Rust library that provides a fast and efficient Serializer and
Deserializer for the "BARE" (Basic Ad-hoc Runtime Encoding) data format. This
format focuses on being simple, small, fast and working well with anonymous
types, making it useful for sending small ad-hoc messages between systems.

To type messages on the wire, I'm wrapping them in "envelope" enums. These envelopes
then implement an unwrap method that returns a Box<dyn Any>, and we require messages
to be Into their envelope type. It's some boilerplate, but I ultimately like leaning
on Rust more than an external schema, which adds complexity.

I also reworked network abstraction to be just in terms of bytes. Typed handlers
are moved into network-neutral code. It's still broken, but hopefully the direction
is clear.

Heads up: I turned on the `backtrace` feature for `anyhow`.

crates/crdb/src/messages.rs

@@ -1,8 +1,30 @@
-use crate::{RepoId, Request, RoomCredentials};
+use crate::{
+    operations::{CreateBranch, CreateDocument, Edit},
+    OperationId, RepoId, Request, RevisionId, RoomCredentials,
+};
 use serde::{Deserialize, Serialize};
-use std::sync::Arc;
+use std::{any::Any, sync::Arc};
 
-#[derive(Clone, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum RequestEnvelope {
+    PublishRepo(PublishRepo),
+}
+
+impl RequestEnvelope {
+    pub fn unwrap(self) -> Box<dyn Any> {
+        Box::new(match self {
+            RequestEnvelope::PublishRepo(request) => request,
+        })
+    }
+}
+
+impl From<Operation> for MessageEnvelope {
+    fn from(value: Operation) -> Self {
+        Self::Operation(value)
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct PublishRepo {
     pub id: RepoId,
     pub name: Arc<str>,
@@ -12,7 +34,51 @@ impl Request for PublishRepo {
     type Response = PublishRepoResponse;
 }
 
+impl Into<RequestEnvelope> for PublishRepo {
+    fn into(self) -> RequestEnvelope {
+        RequestEnvelope::PublishRepo(self)
+    }
+}
+
 #[derive(Clone, Serialize, Deserialize)]
 pub struct PublishRepoResponse {
     pub credentials: RoomCredentials,
 }
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum MessageEnvelope {
+    Operation(Operation),
+}
+
+impl MessageEnvelope {
+    pub fn unwrap(self) -> Box<dyn Any> {
+        Box::new(match self {
+            MessageEnvelope::Operation(message) => message,
+        })
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub enum Operation {
+    CreateDocument(CreateDocument),
+    Edit(Edit),
+    CreateBranch(CreateBranch),
+}
+
+impl Operation {
+    pub fn id(&self) -> OperationId {
+        match self {
+            Operation::CreateDocument(op) => op.id,
+            Operation::Edit(op) => op.id,
+            Operation::CreateBranch(op) => op.id,
+        }
+    }
+
+    pub fn parent(&self) -> &RevisionId {
+        match self {
+            Operation::CreateDocument(op) => &op.parent,
+            Operation::Edit(op) => &op.parent,
+            Operation::CreateBranch(op) => &op.parent,
+        }
+    }
+}