chore: monorepo inicial con arje + minga + yahweh absorbidos

Workspace en 4 ejes (core/modules/apps/shared):

- core/: 24 crates de arje (Init systemd-compatible: ente-card, ente-zero,
  ente-kernel, ente-bus, ente-cas, ente-soma, ente-wasm, ente-snapshot,
  ente-brain, ente-echo, ente-policy-provider, + 12 crates *-compat)
- modules/semantic_dht/: 5 crates de minga (minga-core con AST/CAS/MST,
  minga-p2p con libp2p Kad, minga-store, minga-vfs, minga-cli)
- modules/ui_engine/: 11 crates de yahweh (libs/{core,theme,bus,providers},
  widgets/{tree,splitter,tabs,tiled,container_core,text_input})
- apps/: 5 crates de yahweh (file_explorer, database_explorer, text_viewer,
  image_viewer, yahweh-shell)
- shared_wit/protocol.wit: handshake/lifecycle inicial

Cargo.toml unificado: thiserror bumped a 2 (transparente para arje), tokio
"full", paths intra-workspace de yahweh redirigidos a su nueva ubicación.

cargo check --workspace: 0 errores, 17 warnings (dead code preexistente).

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

shared_wit/protocol.wit

@@ -0,0 +1,109 @@
+// Brahman — Protocolo central (handshake & ciclo de vida)
+//
+// Esta interfaz es el contrato de los módulos "conscientes". Los módulos
+// agnósticos sólo presentan un manifest TOML y son supervisados por convención
+// mínima; los módulos con WIT pueden negociar capacidades, reportar estado y
+// recibir señales del Admin.
+//
+// Versionado: este archivo declara `0.1.0`. Cambios major requieren un nuevo
+// archivo (`protocol-v2.wit`); cambios minor son aditivos.
+
+package brahman:protocol@0.1.0;
+
+interface types {
+    /// Identificador opaco emitido por el Admin tras un handshake exitoso.
+    type session-id = string;
+
+    /// Timestamp UNIX en segundos.
+    type unix-ts = u64;
+
+    record module-info {
+        /// Nombre canónico (debe coincidir con el manifest).
+        name: string,
+        /// SemVer del módulo.
+        version: string,
+        /// Versión del protocolo Brahman implementada.
+        protocol-version: string,
+        /// Capacidades que ofrece (ids libres, idealmente URIs).
+        provides: list<string>,
+        /// Capacidades que requiere para arrancar.
+        requires: list<string>,
+    }
+
+    record admin-info {
+        /// Versión del Admin que aceptó el handshake.
+        version: string,
+        /// Versión del protocolo soportada por el Admin.
+        protocol-version: string,
+        /// Identificador de sesión asignado.
+        session: session-id,
+        /// Si el Init está vinculado al Admin actualmente.
+        init-attached: bool,
+    }
+
+    /// Errores comunes durante negociación o ciclo de vida.
+    variant protocol-error {
+        protocol-mismatch(string),
+        unauthorized(string),
+        capability-unmet(string),
+        rejected(string),
+        internal(string),
+    }
+}
+
+interface handshake {
+    use types.{module-info, admin-info, protocol-error, session-id};
+
+    /// Negociación inicial de un módulo con el Admin.
+    /// El Admin valida protocolo, capacidades requeridas y permisos.
+    hello: func(info: module-info) -> result<admin-info, protocol-error>;
+
+    /// Cierre limpio (drena conexiones, libera recursos).
+    farewell: func(session: session-id) -> result<_, protocol-error>;
+
+    /// Latido para mantener viva la sesión. Devuelve el reloj del Admin.
+    ping: func(session: session-id) -> result<u64, protocol-error>;
+}
+
+interface lifecycle {
+    use types.{session-id, unix-ts, protocol-error};
+
+    enum module-state {
+        initializing,
+        ready,
+        running,
+        suspended,
+        degraded,
+        terminating,
+    }
+
+    record state-report {
+        state: module-state,
+        timestamp: unix-ts,
+        detail: option<string>,
+    }
+
+    /// Reporta cambio de estado al Admin (telemetría → Init si está adjunto).
+    report-state: func(session: session-id, report: state-report) -> result<_, protocol-error>;
+
+    /// Señal del Admin solicitando suspensión cooperativa.
+    on-suspend: func(session: session-id) -> result<_, protocol-error>;
+
+    /// Señal del Admin solicitando reanudación.
+    on-resume: func(session: session-id) -> result<_, protocol-error>;
+}
+
+/// Mundo que un módulo Brahman implementa.
+world module {
+    import handshake;
+    import lifecycle;
+
+    /// Punto de entrada que el Admin invoca tras instanciar el componente.
+    export run: func() -> result<_, string>;
+}
+
+/// Mundo que el Admin implementa (host-side) para los módulos.
+world admin-host {
+    export handshake;
+    export lifecycle;
+}