feat(sidecar): WIT al sidecar — módulos conscientes vivos

Cierra el ciclo brahman-card-wit ↔ runtime: un módulo que tenga su
.wit lo parsea, lo manda en Hello, y aparece como "consciente" en el
broker y en brahman-status.

Cambios coordinados (un solo commit por la cadena de tipos):

- brahman-card::WitInterface deriva Serialize/Deserialize/Eq.
- brahman-handshake::Hello lleva wit: Option<WitInterface> (#[serde(default)]
  para tolerar Hellos antiguos en formato JSON aunque postcard exige
  presencia explícita).
- Server's register_session enruta a ResolvedCard::from_conscious cuando
  viene wit; from_agnostic cuando no.
- Client::connect queda como wrapper de connect_with(path, card,
  wit: Option<WitInterface>) — backward-compatible.
- Broker::register acepta Option<WitInterface> como tercer arg; BrokeredCard
  guarda el wit. 25 sitios de tests actualizados con `, None` (vía perl).
- brahman-sidecar::SidecarConfig.wit + helpers SidecarConfig::with_wit
  y spawn_conscious(card, wit). Log attached reporta conscious=true|false.
- brahman-status pretty-print con 🧠 + sección wit (package/world +
  imports + exports) por sesión consciente.
- Example nuevo presence-conscious: parsea protocol.wit y se presenta
  consciente.

Validación end-to-end manual:

  $ ente-zero &
  $ presence-conscious demo.conscious shared_wit/protocol.wit &
  $ brahman-status
  Sessions (1):
    01K... demo.conscious 🧠  lifecycle=Daemon
        wit: brahman:protocol@0.1.0 / module
             imports: types, handshake, lifecycle
             exports: run

Tests: 32/32 (broker 11 + card 8 + handshake codec+transport 2 + integ 7
+ admin 0 + card-wit 4). Workspace: 0 errores.

CHANGELOG.md actualizado.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

crates/shared/brahman-sidecar/src/lib.rs

@@ -19,7 +19,7 @@
 use std::thread::JoinHandle;
 use std::time::Duration;
 
-use brahman_card::Card;
+use brahman_card::{Card, WitInterface};
 use brahman_handshake::{client::Client, transport};
 use tracing::{info, warn};
 
@@ -31,28 +31,47 @@ pub const DEFAULT_PING_INTERVAL: Duration = Duration::from_secs(30);
 pub struct SidecarConfig {
     /// Card que se presenta al Init.
     pub card: Card,
+    /// WIT interface opcional. Si es `Some`, el módulo se registra como
+    /// "consciente" (`ResolvedCard::from_conscious`).
+    pub wit: Option<WitInterface>,
     /// Período entre pings.
     pub ping_interval: Duration,
 }
 
 impl SidecarConfig {
-    /// Configuración con defaults razonables: ping cada 30s.
+    /// Configuración agnóstica con defaults razonables (sin WIT, ping 30s).
     pub fn new(card: Card) -> Self {
         Self {
             card,
+            wit: None,
             ping_interval: DEFAULT_PING_INTERVAL,
         }
     }
+
+    /// Configuración consciente con WIT extraída.
+    pub fn with_wit(mut self, wit: WitInterface) -> Self {
+        self.wit = Some(wit);
+        self
+    }
 }
 
-/// Spawn fire-and-forget. Devuelve inmediatamente; el handle se descarta.
-/// Si el thread no se puede crear (raro), loggea y sigue.
+/// Spawn fire-and-forget agnóstico. Para módulos conscientes usá
+/// [`spawn_conscious`] o [`spawn_with_handle`] con un `SidecarConfig`
+/// personalizado.
 pub fn spawn(card: Card) {
     if let Err(e) = spawn_with_handle(SidecarConfig::new(card)) {
         warn!(error = %e, "no se pudo spawnear el sidecar brahman");
     }
 }
 
+/// Spawn fire-and-forget con WIT. Idéntico a [`spawn`] pero el módulo se
+/// registra como consciente en el broker.
+pub fn spawn_conscious(card: Card, wit: WitInterface) {
+    if let Err(e) = spawn_with_handle(SidecarConfig::new(card).with_wit(wit)) {
+        warn!(error = %e, "no se pudo spawnear el sidecar brahman");
+    }
+}
+
 /// Spawn devolviendo el `JoinHandle` para tests o cleanup explícito.
 pub fn spawn_with_handle(config: SidecarConfig) -> std::io::Result<JoinHandle<()>> {
     std::thread::Builder::new()
@@ -77,13 +96,15 @@ fn run_thread(config: SidecarConfig) {
 
 async fn run_client(config: SidecarConfig) {
     let path = transport::default_socket_path();
-    let mut client = match Client::connect(&path, config.card).await {
+    let conscious = config.wit.is_some();
+    let mut client = match Client::connect_with(&path, config.card, config.wit).await {
         Ok(c) => {
             info!(
                 target: "brahman_sidecar",
                 session = %c.session(),
                 init_attached = c.server_info().init_attached,
                 server = %c.server_info().server_version,
+                conscious,
                 "attached"
             );
             c