refactor(monorepo): reorganización lógica + renames + SDDs + split CHANGELOG

Reorganización física de crates/:
- core/ (mezclaba 6 propósitos) se divide en protocol/, init/, runtime/, compat/
- shared/ (3 crates) se redistribuye en protocol/ e init/
- lapaloma (sub-módulo de ui_engine) se promueve a modules/pineal/

Renames de proyectos:
- shipote → shuma (runtime de sandboxes)
- nouser → akasha (explorador de Mónadas)
- yahweh → nahual (motor GPUI, antes ui_engine/)
- lapaloma → pineal (data-viz agnóstica)

Fraccionamiento UI → core agnóstico:
- vista-core (DeckState + snap, 175 LOC, 5 tests verdes)
- barra-core (Task + render_html + sanitize, 90 LOC, 5 tests verdes)
- vista-web y barra-web ahora son thin DOM bindings

Documentación nueva:
- 16 SDDs por subdirectorio (≤80 LOC c/u): protocol/init/runtime/compat
  + 10 módulos + apps/
- docs/STATUS.md con cifras reales por proyecto
- docs/ROADMAP.md con plan a finalización (6 hitos, ~6-8 semanas)
- CHANGELOG.md particionado en docs/changelog/<proyecto>.md (7 buckets)

Automatización:
- scripts/reorg.py — script idempotente que: git mv directorios, renombra
  package names, recomputa path = refs, reescribe imports rust, actualiza
  workspace Cargo.toml. Soporta --dry-run.
- scripts/split-changelog.py — particiona CHANGELOG por componente.

Validación:
- cargo check --workspace pasa (124 crates + 2 nuevos cores).
- 10 tests adicionales (5 en vista-core + 5 en barra-core) verdes.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

crates/init/ente-snapshot/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "ente-snapshot"
+version = "0.0.1"
+edition.workspace = true
+license.workspace = true
+publish.workspace = true
+
+[dependencies]
+ente-card = { path = "../../protocol/ente-card" }
+serde = { workspace = true }
+serde_json = { workspace = true }
+ulid = { workspace = true }
+anyhow = { workspace = true }

crates/init/ente-snapshot/src/lib.rs

@@ -0,0 +1,61 @@
+//! Persistencia del fractal. Captura el estado live (Cards encarnadas con
+//! sus identidades preservadas) a un blob JSON. Al restaurar, las mismas
+//! Ulids vuelven a la vida — los PIDs cambian (kernel no los preserva) pero
+//! el grafo se reconstruye con la misma topología.
+//!
+//! Lo que NO se persiste:
+//!   - PIDs (irrelevantes tras reboot)
+//!   - bus_connections (runtime-only)
+//!   - pending_invokes (en vuelo, se descartan)
+//!   - device presence (uevents reconstruyen el índice)
+
+use ente_card::EntityCard;
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+use ulid::Ulid;
+
+pub const SNAPSHOT_VERSION: u16 = 1;
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct FractalSnapshot {
+    pub version: u16,
+    pub timestamp_ms: u64,
+    pub seed_id: Ulid,
+    pub seed_label: String,
+    /// Cards live al momento del checkpoint, excluyendo la Semilla.
+    /// Al restaurar se inyectan en `genesis` con sus Ulids originales.
+    pub entes: Vec<EntityCard>,
+}
+
+impl FractalSnapshot {
+    pub fn write(&self, path: &Path) -> anyhow::Result<()> {
+        let bytes = serde_json::to_vec_pretty(self)?;
+        if let Some(parent) = path.parent() {
+            std::fs::create_dir_all(parent).ok();
+        }
+        // Escritura atómica: temp file + rename.
+        let tmp = path.with_extension("tmp");
+        std::fs::write(&tmp, &bytes)?;
+        std::fs::rename(&tmp, path)?;
+        Ok(())
+    }
+
+    pub fn read(path: &Path) -> anyhow::Result<Self> {
+        let bytes = std::fs::read(path)?;
+        let snap: FractalSnapshot = serde_json::from_slice(&bytes)?;
+        if snap.version != SNAPSHOT_VERSION {
+            anyhow::bail!(
+                "snapshot version {} no soportada (esperada {})",
+                snap.version, SNAPSHOT_VERSION
+            );
+        }
+        Ok(snap)
+    }
+}
+
+pub fn now_ms() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::UNIX_EPOCH)
+        .map(|d| d.as_millis() as u64)
+        .unwrap_or(0)
+}