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>

crates/modules/ui_engine/libs/providers/fs/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "yahweh-provider-fs"
+version = { workspace = true }
+edition = { workspace = true }
+license = { workspace = true }
+description = "DataProvider de filesystem local."
+
+[dependencies]
+yahweh-core = { workspace = true }
+async-trait = { workspace = true }
+tokio = { workspace = true }
+notify = { workspace = true }

crates/modules/ui_engine/libs/providers/fs/src/lib.rs

@@ -0,0 +1,67 @@
+//! Provider de filesystem local. Crate puro: cero dependencia de UI.
+//! Implementa `yahweh_core::DataProvider` listando hijos de un path con
+//! `std::fs::read_dir` y leyendo archivos a `Vec<u8>` via `tokio::io`.
+
+use async_trait::async_trait;
+use std::fs;
+use std::io::Cursor;
+use std::path::Path;
+use std::pin::Pin;
+use tokio::io::{AsyncRead, AsyncWrite};
+use yahweh_core::{DataProvider, DisplayType, EntityNode};
+
+pub const PROVIDER_ID: &str = "local_fs";
+
+pub struct FileDataProvider;
+
+#[async_trait]
+impl DataProvider for FileDataProvider {
+    fn provider_id(&self) -> String {
+        PROVIDER_ID.to_string()
+    }
+
+    async fn list_children(&self, parent_id: Option<&str>) -> Result<Vec<EntityNode>, String> {
+        let path = parent_id.unwrap_or(".");
+        let mut children = Vec::new();
+
+        if let Ok(entries) = fs::read_dir(path) {
+            for entry in entries.filter_map(|e| e.ok()) {
+                let path = entry.path();
+                let name = path
+                    .file_name()
+                    .unwrap_or_default()
+                    .to_string_lossy()
+                    .into_owned();
+                let display_type = if path.is_dir() {
+                    DisplayType::Folder
+                } else {
+                    DisplayType::File
+                };
+
+                children.push(EntityNode {
+                    id: path.to_string_lossy().into_owned(),
+                    name,
+                    display_type,
+                    mime_type: None,
+                });
+            }
+        }
+
+        Ok(children)
+    }
+
+    async fn get_read_stream(
+        &self,
+        entity_id: &str,
+    ) -> Result<Pin<Box<dyn AsyncRead + Send>>, String> {
+        let content = fs::read(Path::new(entity_id)).map_err(|e| e.to_string())?;
+        Ok(Box::pin(Cursor::new(content)))
+    }
+
+    async fn get_write_stream(
+        &self,
+        _entity_id: &str,
+    ) -> Result<Pin<Box<dyn AsyncWrite + Send>>, String> {
+        Err("Escritura en streaming no implementada para FS".to_string())
+    }
+}