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/examples/presence-conscious.rs

@@ -0,0 +1,99 @@
+//! `presence-conscious` — módulo brahman que se presenta con su WIT.
+//!
+//! Variante de [`presence`] que toma un path a un archivo `.wit` (default
+//! `shared_wit/protocol.wit` resuelto desde el cwd) y lo parsea con
+//! `brahman-card-wit` antes de spawnear el sidecar. Demuestra el flujo
+//! "módulo consciente": Hello incluye `WitInterface`, el server lo
+//! registra como `ResolvedCard::from_conscious`, y aparece con marker
+//! 🧠 en `brahman-status`.
+//!
+//! Uso:
+//! ```sh
+//! cargo run -p brahman-sidecar --example presence-conscious -- mi-modulo [path/al.wit]
+//! ```
+
+use std::collections::BTreeSet;
+use std::path::PathBuf;
+use std::time::Duration;
+
+use brahman_card::{
+    ulid::Ulid, Card, Flow, Flows, Lifecycle, Payload, Priority, Supervision, TypeRef,
+    CARD_SCHEMA_VERSION,
+};
+use brahman_sidecar::{spawn_with_handle, SidecarConfig};
+
+fn main() {
+    tracing_subscriber::fmt()
+        .with_env_filter(
+            tracing_subscriber::EnvFilter::try_from_default_env()
+                .unwrap_or_else(|_| "info".into()),
+        )
+        .init();
+
+    let mut args = std::env::args().skip(1);
+    let label = args.next().unwrap_or_else(|| "conscious-default".into());
+    let wit_path: PathBuf = args
+        .next()
+        .map(PathBuf::from)
+        .unwrap_or_else(|| PathBuf::from("shared_wit/protocol.wit"));
+
+    let wit = match brahman_card_wit::parse_wit_file(&wit_path) {
+        Ok(worlds) => match worlds.into_iter().next() {
+            Some(w) => {
+                eprintln!(
+                    "[{label}] cargado wit: {} / {}",
+                    w.package, w.world
+                );
+                Some(w)
+            }
+            None => {
+                eprintln!("[{label}] {} no declara worlds", wit_path.display());
+                None
+            }
+        },
+        Err(e) => {
+            eprintln!("[{label}] falló parse de {}: {e}", wit_path.display());
+            None
+        }
+    };
+
+    let card = Card {
+        schema_version: CARD_SCHEMA_VERSION,
+        id: Ulid::new(),
+        label: label.clone(),
+        payload: Payload::Virtual,
+        supervision: Supervision::OneShot,
+        lifecycle: Lifecycle::Daemon,
+        priority: Priority::Normal,
+        provides: BTreeSet::new(),
+        requires: BTreeSet::new(),
+        flow: Flows {
+            input: vec![Flow {
+                name: "in".into(),
+                ty: TypeRef::Primitive {
+                    name: "json".into(),
+                },
+                pin_to: None,
+            }],
+            output: vec![Flow {
+                name: "out".into(),
+                ty: TypeRef::Primitive {
+                    name: "json".into(),
+                },
+                pin_to: None,
+            }],
+        },
+        ..Default::default()
+    };
+
+    let config = SidecarConfig {
+        card,
+        wit,
+        ping_interval: Duration::from_secs(5),
+    };
+
+    let _handle = spawn_with_handle(config);
+
+    eprintln!("[{label}] sidecar lanzado, durmiendo (Ctrl-C para salir)");
+    std::thread::park();
+}

crates/shared/brahman-sidecar/examples/presence.rs

@@ -61,6 +61,7 @@ fn main() {
 
     let _handle = spawn_with_handle(SidecarConfig {
         card,
+        wit: None,
         ping_interval: Duration::from_secs(5),
     });