docs(Common): Condense README to benefit-focused overview

Simplify the Common crate README from verbose technical documentation to a concise, benefit-oriented overview. Replace 150+ lines of detailed architecture explanations, code examples, and getting started guides with bullet points emphasizing key value propositions: pure abstract traits, compile-time enforcement, and millisecond tests.

Key changes:
- Add VS Code comparison blockquote: "VS Code's codebase imports concrete implementations directly..."
- Switch Rust icon from cdn.simpleicons.org to editor.land/Image/Rust.svg (branded asset)
- Remove detailed "ActionEffect System Explained" with code samples
- Remove "Core Architecture Principles" table
- Remove "Getting Started" section with installation/usage examples
- Condense mermaid diagram to simpler "In the Ecosystem" section
- Update "See Also" links to point to editor.land documentation

The README now serves as a quick onboarding anchor point with links to detailed docs rather than a self-contained tutorial.

Author: NikolaRHristov

README.md

@@ -7,109 +7,67 @@
 </h3> </td>
 </tr></table>
 
----
 
-# **Common** 👨🏻‍🏭
+---
 
-The Architectural Core of Land
+# **Common**&#x2001;👨🏻‍🏭
 
-[![License: CC0-1.0](https://img.shields.io/badge/License-CC0_1.0-lightgrey.svg)](https://github.com/CodeEditorLand/Common/tree/Current/LICENSE)
-[<img src="https://cdn.simpleicons.org/rust" width="14" alt="Rust" />](https://www.rust-lang.org/)&#x2001;[![Rust Version](https://img.shields.io/badge/Rust-1.85+-blue.svg)](https://www.rust-lang.org/)
-[<img src="https://cdn.simpleicons.org/rust" width="14" alt="Rust" />](https://www.rust-lang.org/)&#x2001;[![Crates.io](https://img.shields.io/crates/v/land-common.svg)](https://crates.io/crates/land-common)
-
-Welcome to **Common**! This crate is the architectural heart of the Land Code
-Editor's native backend. It provides a pure, abstract foundation for building
-application logic using a declarative, effects-based system. It contains **no
-concrete implementations**; instead, it defines the "language" of the
-application through a set of powerful, composable building blocks.
-
-The entire `Mountain` backend and any future native components are built by
-implementing the traits and consuming the effects defined in this crate.
-
-**What Common gives you:**
-
-1. **Test without Tauri.** Every capability is an abstract trait. Mock the trait,
-   test your logic. No window, no webview, no sidecar needed.
-2. **Bugs at compile time.** The `ActionEffect` type describes operations as
-   values. The compiler catches missing dependencies and type mismatches before
-   runtime.
-3. **One error enum, everywhere.** `CommonError` covers every failure domain.
-   No stringly-typed errors, no `unwrap()` surprises.
-4. **Stable IPC contracts.** DTOs are `serde`-compatible and shared across
-   Mountain, Cocoon, and Wind. Change the type, and every consumer gets a
-   compile error.
+> **VS Code's codebase imports concrete implementations directly. Testing a single component means mocking entire subsystems. There is no dependency injection at the architecture level.**
 
-📖 **[Rust API Documentation](https://Rust.Documentation.Editor.Land/Common/)**
+_"Mock any service and test any element in isolation, no running editor required."_
 
----
+[![License: CC0-1.0](https://img.shields.io/badge/License-CC0_1.0-lightgrey.svg)](https://github.com/CodeEditorLand/Common/tree/Current/LICENSE)
+[<img src="https://editor.land/Image/Rust.svg" width="14" alt="Rust" />](https://www.rust-lang.org/)&#x2001;[![Rust Version](https://img.shields.io/badge/Rust-1.85+-blue.svg)](https://www.rust-lang.org/)
+[<img src="https://editor.land/Image/Rust.svg" width="14" alt="Rust" />](https://www.rust-lang.org/)&#x2001;[![Crates.io](https://img.shields.io/crates/v/land-common.svg)](https://crates.io/crates/land-common)
 
-## Key Features & Concepts 🔐
+Common defines pure abstract traits with zero concrete implementations. Every element builds on Common's typed effects and composable building blocks. The Rust compiler enforces contracts at build time. If an element changes its signature, every consumer fails to compile immediately. Tests run in milliseconds because you can mock any trait and test any element without launching a window, a WebView, or a sidecar.
 
-- **Declarative effects, not callbacks.** Operations are data. Describe what
-  you want, compose effects, then run them. Testing is trivial: just inspect
-  the effect value without executing it.
-- **Compile-time dependency injection.** The `Environment` and `Requires` traits
-  wire dependencies at compile time. No runtime reflection, no service locator.
-- **Async-first.** Every service trait (`FileSystemReader`, `CommandExecutor`,
-  etc.) is `async`. No blocking calls anywhere in the contract.
-- **Shared DTOs for all IPC.** Mountain, Cocoon, and Wind all use the same
-  `serde`-compatible types. Schema changes break at compile time, not at runtime.
-- **One error type.** `CommonError` covers all 20 service domains. Pattern match
-  once, handle every case.
+📖 **[Rust API Documentation](https://Rust.Documentation.Editor.Land/Common/)**
 
 ---
 
-## Core Architecture Principles 🏗️
+## What It Does&#x2001;🔐
 
-| Principle          | Description                                                                                                                                    | Key Components Involved                    |
-| :----------------- | :--------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------- |
-| **Abstraction**    | Define every application capability as an abstract `async trait`. Never include concrete implementation logic.                                 | All `*Provider.rs` and `*Manager.rs` files |
-| **Declarativism**  | Represent every operation as an `ActionEffect` value. The crate provides constructor functions for these effects.                              | `Effect/*`, all effect constructor files   |
-| **Composability**  | The `ActionEffect` system and trait-based DI are designed to be composed, allowing complex workflows to be built from simple, reusable pieces. | `Environment/*`, `Effect/*`                |
-| **Contract-First** | Define all data structures (`DTO/*`) and error types (`Error/*`) first. These form the stable contract for all other components.               | `DTO/`, `Error/`                           |
-| **Purity**         | This crate has minimal dependencies and is completely independent of Tauri, gRPC, or any specific application logic.                           | `Cargo.toml`                               |
+- **Pure abstract traits.** Zero concrete implementations. Every cross-element boundary is a typed contract.
+- **Compile-time enforcement.** Change a trait signature and every consumer fails to compile immediately.
+- **Millisecond tests.** Mock any trait and test any element without launching a window or WebView.
+- **ActionEffect system.** Declarative effects that are composable, testable, and type-safe.
 
 ---
 
-## The `ActionEffect` System Explained
-
-The core pattern in `Common` is the `ActionEffect`. Instead of writing a
-function that immediately performs a side effect, you call a function that
-_returns a description of that effect_.
+## In the Ecosystem&#x2001;👨🏻‍🏭 + 🏞️
 
-**Traditional (Imperative) Approach:**
+```mermaid
+graph LR
+    classDef Mountain fill:#f9f,stroke:#333,stroke-width:2px;
+    classDef Common fill:#cfc,stroke:#333,stroke-width:1px;
+    classDef Consumer fill:#9cf,stroke:#333,stroke-width:2px;
 
-```rust
-async fn read_my_file(fs: &impl FileSystem) -> Result<Vec<u8>, Error> {
-// The side effect happens here.
-    fs.read("/path/to/file").await
-}
-```
+    subgraph "The \`Common\` Crate"
+        direction LR
+        Traits["Abstract Traits (e.g., \`FileSystemReader\`)"]:::Common
+        Effects["ActionEffects (e.g., \`ReadFile\`)"]:::Common
+        DTOs["Data Transfer Objects (e.g., \`FileTypeDTO\`)"]:::Common
 
-**The `Common` (Declarative) Approach:**
+        Effects -- Depend on --> Traits
+    end
 
-```rust
-use CommonLibrary::FileSystem;
-use std::sync::Arc;
+    subgraph "Consumers"
+        Mountain[**Mountain Application**]:::Mountain
+        Tests[Unit & Integration Tests]:::Consumer
+    end
 
-// 1. Create a description of the desired effect. No I/O happens here.
-//    The effect's type signature explicitly declares its dependency: `Arc<dyn FileSystemReader>`.
-let read_effect: ActionEffect<Arc<dyn FileSystemReader>, _, _> = FileSystem::ReadFile(PathBuf::from("/path/to/file"));
+    Mountain -- Implements --> Traits
+    Mountain -- Executes --> Effects
+    Mountain -- Uses --> DTOs
 
-// 2. Later, in a separate part of the system (the runtime), execute it.
-//    The runtime will see that the effect needs a FileSystemReader, provide one from its
-//    environment, and run the operation.
-let file_content = runtime.Run(read_effect).await?;
+    Tests -- Mocks --> Traits
+    Tests -- Verifies --> Effects
 ```
 
-This separation makes the architecture flexible and testable.
-
 ---
 
-## Project Structure Overview 🗺️
-
-The `Common` crate is organized by service domain, with each domain containing
-its trait definitions, DTOs, and effect constructors.
+## Project Structure&#x2001;🗺️
 
 ```
 Common/
@@ -155,138 +113,31 @@ Common/
 
 ---
 
-## Deep Dive & Architectural Patterns 🔬
-
-To understand the core philosophy behind this crate and how its components work
-together, please refer to the detailed technical breakdown in
-[`Documentation/GitHub/DeepDive.md`](https://github.com/CodeEditorLand/Common/tree/Current/Documentation/GitHub/DeepDive.md).
+## Development&#x2001;🛠️
 
-This document explains the `ActionEffect` system, the trait-based dependency
-injection model, and provides a guide for adding new services to the
-architecture.
+Common is a component of the Land workspace. Follow the
+[Land Repository](https://github.com/CodeEditorLand/Land) instructions to
+build and run.
 
 ---
 
-## How `Common` Fits into the `Land` Ecosystem 👨🏻‍🏭 + 🏞️
+## License&#x2001;⚖️
 
-`Common` is the foundational layer upon which the entire native backend is
-built. It has no knowledge of its consumers, but they are entirely dependent on
-it.
-
-```mermaid
-graph LR
-    classDef Mountain fill:#f9f,stroke:#333,stroke-width:2px;
-    classDef Common fill:#cfc,stroke:#333,stroke-width:1px;
-    classDef Consumer fill:#9cf,stroke:#333,stroke-width:2px;
-
-    subgraph "The \`Common\` Crate"
-        direction LR
-        Traits["Abstract Traits (e.g., \`FileSystemReader\`)"]:::Common
-        Effects["ActionEffects (e.g., \`ReadFile\`)"]:::Common
-        DTOs["Data Transfer Objects (e.g., \`FileTypeDTO\`)"]:::Common
-
-        Effects -- Depend on --> Traits
-    end
-
-    subgraph "Consumers"
-        Mountain[**Mountain Application**]:::Mountain
-        Tests[Unit & Integration Tests]:::Consumer
-    end
-
-    Mountain -- Implements --> Traits
-    Mountain -- Executes --> Effects
-    Mountain -- Uses --> DTOs
-
-    Tests -- Mocks --> Traits
-    Tests -- Verifies --> Effects
-```
-
----
-
-## Getting Started 🚀
-
-### Installation 📥
-
-`Common` is intended to be used as a local path dependency within the `Land`
-workspace. In `Mountain`'s `Cargo.toml`:
-
-```toml
-[dependencies]
-Common = { path = "../Common" }
-```
-
-### Usage 🚀
-
-A developer working within the `Mountain` codebase would use `Common` as
-follows:
-
-1. **Implement a Trait:** In `Mountain/Source/Environment/`, provide the
-   concrete implementation for a `Common` trait.
-
-```rust
-// In Mountain/Source/Environment/FileSystemProvider.rs
-
-use CommonLibrary::FileSystem::{FileSystemReader, FileSystemWriter};
-
-#[async_trait]
-impl FileSystemReader for MountainEnvironment {
-	async fn ReadFile(&self, Path: &PathBuf) -> Result<Vec<u8>, CommonError> {
-		// ... actual `tokio::fs` call ...
-	}
-
-	// ...
-}
-```
-
-2. **Create and Execute an Effect:** In business logic, create and run an
-   effect.
-
-```rust
-// In a Mountain service or command
-
-use CommonLibrary::FileSystem;
-use CommonLibrary::Effect::ApplicationRunTime;
-
-async fn some_logic(runtime: Arc<impl ApplicationRunTime>) {
-	let path = PathBuf::from("/my/file.txt");
-	let read_effect = FileSystem::ReadFile(path);
-
-	match runtime.Run(read_effect).await {
-		Ok(content) => info!("File content length: {}", content.len()),
-		Err(e) => error!("Failed to read file: {:?}", e),
-	}
-}
-```
+CC0 1.0 Universal. Public domain. No restrictions.
+[LICENSE](https://github.com/CodeEditorLand/Common/tree/Current/LICENSE)
 
 ---
 
-## License ⚖️
-
-This project is released into the public domain under the **Creative Commons CC0
-Universal** license.
-
-You are free to use, modify, distribute, and build upon this work for any
-purpose, without any restrictions. For the full legal text, see the
-[`LICENSE`](https://github.com/CodeEditorLand/Common/tree/Current/) file.
-
----
-
-## Changelog 📜
-
-Stay updated with our progress! See
-[`CHANGELOG.md`](https://github.com/CodeEditorLand/Common/tree/Current/) for a
-history of changes specific to **Common**.
-
----
-
-
 ## See Also
 
+- [Common Documentation](https://editor.land/Doc/common)
 - [Architecture Overview](https://editor.land/Doc/architecture)
+- [Why Rust](https://editor.land/Doc/why-rust)
 - [Mountain](https://github.com/CodeEditorLand/Mountain)
 - [Echo](https://github.com/CodeEditorLand/Echo)
 - [Air](https://github.com/CodeEditorLand/Air)
 
+
 ## Funding & Acknowledgements 🙏🏻
 
 **Common** is a core element of the **Land** ecosystem. This project is funded