feat: add dialects/ scaffolds for 3 Tangle-hosted DSLs

Evidence that Tangle is a multi-DSL host, not a single-purpose language.
Each scaffold is a grammar sketch + README — explicitly NOT an
implementation.

New scaffolds:
- dialects/braid-calculus/: Artin braid group Bn calculus (σᵢ^k, multiplication,
  Markov equivalence)
- dialects/quantum-circuit/: compositional quantum circuits (H/X/Y/Z/CNOT/
  parameterised gates, sequential ; + tensor ⊗)
- dialects/string-diagram/: monoidal category string diagrams (then / tensor /
  id / braiding / associator / unitor)

Pattern established: sketches live here, graduate to own top-level repo
when implementation begins (following krl/ precedent). KRL is cross-linked
as the first graduated example.

Addresses READINESS.md path-to-B: 'Build 5 more DSLs on top of Tangle
(not just KRL)'. 3 sketches down, 2 more to go — plus upgrading these
from sketch → alpha.

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

Author: hyperpolymath

dialects/README.md

@@ -0,0 +1,49 @@
+# Tangle Dialects — hosted DSL scaffolds
+
+Tangle is a Turing-complete topological programming language. It is NOT
+a DSL host by accident — it was designed to support compositional
+calculi grounded in knot theory, category theory, and related algebraic
+structures.
+
+This directory holds *scaffolds* for DSLs that could be hosted on Tangle.
+Each scaffold is an EBNF grammar sketch — evidence that the idea is
+coherent and could be built out, not a complete implementation.
+
+## The pattern
+
+When a DSL matures from sketch → alpha implementation, it should follow
+the KRL precedent:
+
+1. Start with an EBNF grammar sketch here (`grammar-sketch.ebnf`)
+2. Write 1-3 example programs
+3. When ready to implement: graduate to its own top-level repo (like `krl/`)
+4. Implement parser in Tangle OCaml or sibling language
+5. Wire through to TangleIR or its own IR type
+
+Keeping sketches here demonstrates Tangle's claim to be a general
+multi-DSL host, not a single-purpose language.
+
+## Current scaffolds
+
+| Dialect | Status | Domain |
+|---|---|---|
+| [krl](../../krl/) (separate repo) | grade E | Knot resolution — construct, transform, resolve, retrieve |
+| [braid-calculus](braid-calculus/) | sketch | Artin braid group Bn calculus |
+| [quantum-circuit](quantum-circuit/) | sketch | Quantum circuit compositional calculus |
+| [string-diagram](string-diagram/) | sketch | Monoidal/braided category string diagrams |
+
+## Relationship to KRL
+
+KRL lives at `/var/mnt/eclipse/repos/krl` (sibling top-level repo), NOT
+here. This is intentional: KRL has graduated past the scaffold stage and
+earned its own repo. These scaffolds represent future candidates that
+may graduate similarly.
+
+## Contribution
+
+To propose a new DSL scaffold:
+
+1. Create `dialects/<name>/` with at minimum `grammar-sketch.ebnf`
+2. Write `dialects/<name>/README.md` explaining the domain + 1-2 example programs
+3. Link from this README
+4. Keep it to a sketch — no implementation yet

dialects/braid-calculus/README.md

@@ -0,0 +1,39 @@
+# Braid Calculus — Tangle DSL Sketch
+
+**Status:** sketch. Grammar drafted; no parser or implementation yet.
+
+## Domain
+
+A direct surface language for working in Artin braid groups Bₙ.
+Distinct from KRL by being narrower: braids only, no closure, no knot
+classification. The quotient map Bₙ → Knots is explicit via a `close`
+primitive that hands off to KRL.
+
+## What it supports
+
+- Generators σᵢ (braid crossings) with exponent
+- Inverses σᵢ⁻¹
+- Multiplication of braid words
+- Conjugation
+- Markov moves (for knot invariant construction)
+
+## What it does NOT do
+
+- Closure to knots (that's KRL's job — use `as krl.close(b)`)
+- Invariant computation (that's KnotTheory.jl's job)
+- Persistence (that's Skein.jl's job)
+
+## Example
+
+```braid
+let s1 = sigma 1
+let s2 = sigma 2
+let trefoil_braid = s1 * s1 * s1
+let trefoil_conj = s2 * trefoil_braid * inverse s2
+is_markov_equivalent(trefoil_braid, trefoil_conj)
+```
+
+## See also
+
+- `grammar-sketch.ebnf` — formal grammar
+- `../../../krl/` — knot resolution language (consumes braid words via `close`)

dialects/braid-calculus/grammar-sketch.ebnf

@@ -0,0 +1,23 @@
+(* SPDX-License-Identifier: PMPL-1.0-or-later *)
+(* Braid Calculus — Tangle DSL sketch *)
+
+program       = { statement } ;
+statement     = binding | expression_stmt ;
+
+binding       = "let" , identifier , "=" , expression , ";" ;
+expression_stmt = expression , ";" ;
+
+expression    = mult_expr ;
+mult_expr     = unary_expr , { "*" , unary_expr } ;    (* braid multiplication *)
+unary_expr    = "inverse" , unary_expr
+              | atom ;
+
+atom          = generator
+              | identifier
+              | "(" , expression , ")" ;
+
+generator     = "sigma" , integer , [ "^" , integer ] ;  (* σᵢ^k *)
+
+predicate     = "is_markov_equivalent" , "(" , expression , "," , expression , ")" ;
+
+(* Reserved: let sigma inverse is_markov_equivalent *)

dialects/quantum-circuit/README.md

@@ -0,0 +1,39 @@
+# Quantum Circuit Calculus — Tangle DSL Sketch
+
+**Status:** sketch. Grammar drafted; no parser or implementation yet.
+
+## Domain
+
+Compositional quantum-circuit calculus. Quantum gates map naturally
+to Tangle's compositional operations (sequential = gate-in-time,
+parallel = gate-in-space via tensor product).
+
+## What it supports
+
+- Standard gates (H, X, Y, Z, CNOT, T, S, Swap)
+- Parameterised gates (Rx(θ), Ry(θ), Rz(θ), U3(θ, φ, λ))
+- Sequential composition (;)
+- Parallel composition (⊗) via tensor
+- Measurement operators
+
+## What it does NOT do
+
+- Classical simulation (defer to Yao.jl / Qiskit)
+- Hardware-specific calibration
+- Noise modelling
+
+## Example
+
+```qc
+-- Bell state preparation
+let bell = H on 0 ; CNOT (0, 1) ;
+
+-- Grover iteration kernel
+let oracle = Z on 1 ;
+let diffuser = (H on 0) ⊗ (H on 1) ; Z on 0 ; (H on 0) ⊗ (H on 1) ;
+let grover_step = oracle ; diffuser ;
+```
+
+## See also
+
+- `grammar-sketch.ebnf` — formal grammar

dialects/quantum-circuit/grammar-sketch.ebnf

@@ -0,0 +1,29 @@
+(* SPDX-License-Identifier: PMPL-1.0-or-later *)
+(* Quantum Circuit Calculus — Tangle DSL sketch *)
+
+program     = { statement } ;
+statement   = binding | expression_stmt ;
+
+binding     = "let" , identifier , "=" , expression , ";" ;
+expression_stmt = expression , ";" ;
+
+expression  = seq_expr ;
+seq_expr    = par_expr , { ";" , par_expr } ;          (* time composition *)
+par_expr    = atom , { "⊗" , atom } ;                    (* space / tensor *)
+
+atom        = gate_app
+            | identifier
+            | "(" , expression , ")" ;
+
+gate_app    = fixed_gate , "on" , qubit_spec
+            | param_gate , "(" , param_list , ")" , "on" , qubit_spec
+            | "CNOT" , "(" , qubit_spec , "," , qubit_spec , ")"
+            | "Swap" , "(" , qubit_spec , "," , qubit_spec , ")" ;
+
+fixed_gate  = "H" | "X" | "Y" | "Z" | "S" | "T" ;
+param_gate  = "Rx" | "Ry" | "Rz" | "U3" ;
+
+qubit_spec  = integer ;
+param_list  = expression , { "," , expression } ;
+
+(* Reserved: let H X Y Z S T Rx Ry Rz U3 CNOT Swap on *)

dialects/string-diagram/README.md

@@ -0,0 +1,50 @@
+# String Diagram Calculus — Tangle DSL Sketch
+
+**Status:** sketch. Grammar drafted; no parser or implementation yet.
+
+## Domain
+
+Monoidal/braided category string diagrams. Surface syntax for working
+with morphisms in a symmetric or braided monoidal category, with
+composition (∘), tensor (⊗), identity, and structural morphisms
+(associator, unitor, braiding).
+
+## What it supports
+
+- Object and morphism declarations
+- Sequential composition (∘, or `then`)
+- Tensor product (⊗, or `tensor`)
+- Identity morphism on an object
+- Braiding / symmetry
+- Unit object / unitor
+- Associator
+
+## What it does NOT do
+
+- Type checking beyond domain/codomain matching (would need TypeLL for that)
+- Categorical coherence proofs (would need Agda/Lean)
+- Graphical rendering
+
+## Example
+
+```sd
+object A, B, C ;
+morphism f : A -> B ;
+morphism g : B -> C ;
+morphism h : A -> A ;
+
+let gf    = f then g ;            -- sequential composition A -> C
+let f_id  = f tensor (id A) ;     -- parallel with identity
+let braid = braiding A B ;        -- symmetric structure
+```
+
+## Connection to TangleIR
+
+String diagrams generalise tangles: a tangle is a specific string
+diagram in a braided monoidal category where objects are "strands" and
+morphisms are crossings/caps/cups. KRL's `close`, `tensor`, `mirror`
+operations correspond to categorical operations on string diagrams.
+
+## See also
+
+- `grammar-sketch.ebnf` — formal grammar

dialects/string-diagram/grammar-sketch.ebnf

@@ -0,0 +1,29 @@
+(* SPDX-License-Identifier: PMPL-1.0-or-later *)
+(* String Diagram Calculus — Tangle DSL sketch *)
+
+program     = { declaration } ;
+declaration = object_decl | morphism_decl | binding | expression_stmt ;
+
+object_decl    = "object" , identifier_list , ";" ;
+morphism_decl  = "morphism" , identifier , ":" , type_expr , "->" , type_expr , ";" ;
+binding        = "let" , identifier , "=" , expression , ";" ;
+expression_stmt = expression , ";" ;
+
+type_expr   = identifier
+            | type_expr , "tensor" , type_expr
+            | "unit" ;
+
+expression  = compose_expr ;
+compose_expr = tensor_expr , { "then" , tensor_expr } ;   (* ∘ *)
+tensor_expr  = atom , { "tensor" , atom } ;                (* ⊗ *)
+
+atom        = "id" , type_expr
+            | "braiding" , type_expr , type_expr
+            | "associator" , type_expr , type_expr , type_expr
+            | "unitor" , type_expr
+            | identifier
+            | "(" , expression , ")" ;
+
+identifier_list = identifier , { "," , identifier } ;
+
+(* Reserved: object morphism let id tensor then braiding associator unitor unit *)