docs(rust): full documentation and metadata polish for Rust core

- Add Cargo.toml metadata (license, repository, authors) to workspace and all 3 crates
- Add #![warn(missing_docs)] to core and python crates with 0 warnings
- Document all 248 public items in the core crate (ast, schema, validation,
  value_coercion, compiler, query_parser, reserved_words)
- Add crate-level //! docs and /// module docs to all modules
- Document python crate public structs, add #[allow(missing_docs)] on PyO3 AST wrappers
- Fix all rustdoc broken intra-doc links (14 warnings → 0)
- Write READMEs for core, python crates and rewrite workspace README
- Add Rust Core section to root project README with performance numbers
- Fix Python UP047 lint (TypeVar → PEP 695 type parameter syntax)

Author: ds1sqe

README.md

@@ -363,6 +363,24 @@ uv run pytest -m "" -v                    # Run all tests
 ./check.sh                                # Run linting and type checking
 ```
 
+## Rust Core
+
+The project includes a Rust core (`type-bridge-core/`) that provides high-performance implementations of the query compiler, validation engine, and value coercer. When the native extension is installed, Python automatically delegates to Rust for:
+
+- **Validation** — ~8.6x faster schema-aware query validation
+- **Compilation** — ~1.3x faster AST-to-TypeQL compilation via serde bridge
+- **Value coercion** — Type-safe value coercion and TypeQL literal formatting
+
+The Rust core is a Cargo workspace with three crates:
+
+| Crate | Description |
+|-------|-------------|
+| `type-bridge-core-lib` | Pure-Rust AST, schema parser, query compiler, and validation engine |
+| `type-bridge-core` | PyO3 bindings exposing the Rust core to Python |
+| `type-bridge-server` | Transport-agnostic query pipeline with HTTP API |
+
+See [`type-bridge-core/README.md`](type-bridge-core/README.md) for build instructions and architecture details.
+
 ## Requirements
 
 - Python 3.13+

type-bridge-core/Cargo.toml

@@ -2,5 +2,10 @@
 resolver = "3"
 members = ["crates/core", "crates/python", "crates/server"]
 
+[workspace.package]
+license = "MIT"
+repository = "https://github.com/ds1sqe/type-bridge"
+authors = ["ds1sqe"]
+
 [workspace.lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(coverage_nightly)', 'cfg(coverage)'] }

type-bridge-core/README.md

@@ -1,30 +1,53 @@
 # type-bridge-core
 
-Rust core for the `type-bridge` TypeDB ORM.
+Rust core for the **type-bridge** TypeDB ORM — high-performance AST, schema parser, query compiler, validation engine, and value coercer.
 
-## Overview
+## Workspace structure
 
-This crate provides a high-performance, shared type system and query engine for `type-bridge`. It enables:
-
-- **Bidirectional Validation**: Define validation rules once in Rust and enforce them on both client (Python) and server (Rust/WASM).
-- **Query Object Portability**: First-class AST objects that can be serialized and moved between runtimes.
-- **Performance**: High-speed query compilation and schema parsing.
+```
+type-bridge-core/
+├── Cargo.toml          # Workspace root
+└── crates/
+    ├── core/           # type-bridge-core-lib  (pure Rust, no runtime deps)
+    ├── python/         # type-bridge-core      (PyO3 bindings → Python)
+    └── server/         # type-bridge-server    (query pipeline + HTTP API)
+```
 
-## Structure
+## Crates
 
-- `src/core`: Pure Rust implementation of the AST, schema, and validation engine. This is runtime-agnostic.
-- `src/ast`: PyO3 wrappers for the core AST nodes, providing an idiomatic Python API.
-- `src/lib.rs`: PyO3 module definition.
+| Crate | Description |
+|-------|-------------|
+| [`type-bridge-core-lib`](crates/core/) | Pure-Rust TypeQL AST, schema parser, query compiler, validation engine, and value coercer |
+| [`type-bridge-core`](crates/python/) | PyO3 bindings exposing the Rust core to Python via serde-tagged-enum dicts |
+| [`type-bridge-server`](crates/server/) | Transport-agnostic query pipeline with validation, interceptors, and HTTP API |
 
 ## Building
 
-To build the Python extension:
-
 ```bash
+# Check all crates (requires PYO3 compat flag on Python ≥ 3.14)
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 cargo check --all-targets
+
+# Build the Python extension
 cd type-bridge-core
-maturin develop
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 maturin develop
+
+# Run tests
+cargo test -p type-bridge-core-lib -p type-bridge-server
+
+# Generate docs
+PYO3_USE_ABI3_FORWARD_COMPATIBILITY=1 cargo doc --no-deps --open
+```
+
+## Local CI mirror
+
+Use the project-level check script to mirror CI locally:
+
+```bash
+./scripts/check.sh rust      # Rust checks only
+./scripts/check.sh python    # Python checks only
+./scripts/check.sh           # Both
 ```
 
-## Status
+## License
 
-This is an initial implementation following the RFC in issue #95. Key structures are in place, with logic being ported from Python.
+MIT

type-bridge-core/crates/core/Cargo.toml

@@ -2,6 +2,10 @@
 name = "type-bridge-core-lib"
 version = "0.1.0-dev.0"
 edition = "2024"
+description = "TypeQL AST, schema parser, query compiler, and validation engine for type-bridge"
+license.workspace = true
+repository.workspace = true
+authors.workspace = true
 
 [features]
 default = []

type-bridge-core/crates/core/README.md

@@ -0,0 +1,55 @@
+# type-bridge-core-lib
+
+Pure-Rust TypeQL AST, schema parser, query compiler, validation engine, and value coercer for **type-bridge**.
+
+## Modules
+
+| Module | Purpose |
+|--------|---------|
+| `ast` | TypeQL Abstract Syntax Tree — patterns, statements, clauses, and values |
+| `schema` | Schema representation with entity / relation / attribute types and inheritance resolution |
+| `validation` | Schema-aware query validation plus a portable JSON validation-rule DSL |
+| `compiler` | Compiles an AST back into a TypeQL query string |
+| `query_parser` | Parses a TypeQL query string into the AST (bidirectional round-trip) |
+| `value_coercion` | Coerces raw values into TypeDB value-types and formats TypeQL literals |
+| `reserved_words` | TypeQL reserved-word detection |
+| `parser` | Low-level Winnow grammar consumed by `query_parser` and `schema` |
+
+## Usage
+
+```rust
+use type_bridge_core_lib::query_parser::parse_typeql_query;
+use type_bridge_core_lib::compiler::QueryCompiler;
+use type_bridge_core_lib::schema::TypeSchema;
+use type_bridge_core_lib::validation::ValidationEngine;
+
+// Parse a TypeQL query into AST clauses
+let clauses = parse_typeql_query("match $p isa person, has name 'Alice';").unwrap();
+
+// Compile back to TypeQL
+let compiler = QueryCompiler::new();
+let typeql = compiler.compile(&clauses);
+assert_eq!(typeql, "match $p isa person, has name 'Alice';");
+
+// Validate against a schema
+let schema = TypeSchema::from_typeql("define entity person, owns name; attribute name, value string;").unwrap();
+let engine = ValidationEngine::new();
+let result = engine.validate_query(&clauses, &schema);
+assert!(result.is_valid);
+```
+
+## Feature flags
+
+| Feature | Default | Effect |
+|---------|---------|--------|
+| `pyo3` | no | Enables `#[derive(FromPyObject)]` on AST types for PyO3 interop |
+
+## Testing
+
+```bash
+cargo test -p type-bridge-core-lib
+```
+
+## License
+
+MIT