docs: rename host to owner, guest to reference, and the lifetime owner to scope

CLAUDE.md

@@ -160,7 +160,7 @@ directory argument: `grep` prints `bench/: Is a directory` and silently skips it
 otherwise.
 
 There used to be a guard here matching `&X = bareSymbol`. It is **gone** and
-must not be restored: a bare symbol is a guest source (`spec/memory.md` §2.8),
+must not be restored: a bare symbol is a reference source (`spec/memory.md` §2.8),
 so a match indicates nothing either way — what governs such an assignment is the
 scope comparison in `spec/lifetimes.md` §1.1, which needs the declaration scopes
 of both sides and so cannot be grepped at all.
@@ -180,6 +180,22 @@ reintroduction; fix it. Merged stories say "receiver" throughout and stay that
 way, so the two trees disagree on this word by design. Use `subject` in new
 prose on both sides.
 
+**`guest`, `host`, and the lifetime `owner`.** The `&` is a **reference**, the
+slot that holds an object is its **owner**, and what the store rule compares is
+a place's **scope** (glossary §3.32, §3.33, §3.43). Each guard comes back empty:
+
+```sh
+grep -RIn -i -E "guest|\bhost" spec/ | grep -vF '> **Story:**' | grep -v "^spec/dependencies.md"
+grep -RIn -E "(block|scope)s? owns?\b|owned by (the |its |that |this |an? )?(declaring |enclosing |body )?(block|scope)|owner comparison" spec/
+grep -RIn -i -E "\breference (field|element|parameter|member|slot)s?\b" spec/
+```
+
+The first skips `> **Story:**` pointers, whose quoted chapter headings keep the
+old words, and `dependencies.md`, where a host is a download server. The second
+catches the old lifetime `owner` coming back: a block is a scope, never an
+owner. The third guards spec guide §6.6. Merged stories keep the old words,
+as with `receiver`.
+
 **The separator.** The bracket picks the separator (canonical home
 `spec/lexical.md` §6). `init{ }` and the field-constructor header and call site
 took `,` under the previous rule, and every other C-family language still does,

README.md

@@ -41,7 +41,7 @@ The specification lives in [`spec/`](spec/) and is organized by topic. Each docu
 | [`spec/adt.md`](spec/adt.md) | Enums, variants, the struct/variant symmetry, pattern matching, `match`, and enum maps |
 | [`spec/functions.md`](spec/functions.md) | Methods, free functions, subscripts, overload resolution, function values, and lambdas |
 | [`spec/generics.md`](spec/generics.md) | Unified type parameters, `<>` type expressions, constructor calls, and the `Array`, `ArrayRef`, and `List` container primitives |
-| [`spec/memory.md`](spec/memory.md) | Hosting, settled and roaming hosts, guests, and arena layout |
+| [`spec/memory.md`](spec/memory.md) | Ownership, settled and roaming owners, references, and arena layout |
 | [`spec/lifetimes.md`](spec/lifetimes.md) | Lexical lifetime rules, moves, scope rules, and deterministic destruction |
 | [`spec/effects.md`](spec/effects.md) | The effect model, `mut`, read-only bindings, what each kind of verb may write, and capability wiring |
 | [`spec/concurrency.md`](spec/concurrency.md) | Implicit parallelism, `spawn`, water-tower lifetimes, and concurrency safety |
@@ -69,7 +69,7 @@ The spec states *what* the language does; the **why** lives in a parallel set of
 | [`stories/adt.md`](stories/adt.md) | [`spec/adt.md`](spec/adt.md) — splitting `enum` from `variant` against the hype, the shared struct body, escaping the matcher machine with case overloads and the turn to a central `match` block, matching variants rather than patterns, keeping enum data outside the members, reducing a match group to sugar for one arm per case, building a variant by naming a case rather than calling a constructor, the bindings that existed only to be pointed at, and making a recursive member an owned child boxed through a hosting handle rather than an `&`, and the sum that could not contain itself until a value copy became deep, and why a variant payload cannot originate a guest even though the whole reference variant can, with displaced hosting payloads floating within the same owner |
 | [`stories/generics.md`](stories/generics.md) | [`spec/generics.md`](spec/generics.md) — the parameter model, the `<>`/`()` split, size-in-the-type, the deferred features, why a language without pointers needed a second, dynamically sized container primitive, and why an integer literal and a decimal literal carry different concept types, with the number parameter taking the integer one, and why a wrong-kind type argument is reported where the type was supplied |
 | [`stories/dependencies.md`](stories/dependencies.md) | [`spec/dependencies.md`](spec/dependencies.md) — URL identity, the manifest/resolution split, prebuilt distribution, symbol-rewriting, the browsable global cache, the package-graph acyclicity rule, opt-in remapping, why `core` became a bundled implementation package, the floor that finally made it an ordinary one, moving prebuilt objects to Release assets with committed hashes, and recording where each dependency's code comes from — a release, a source build, or a local path — beside a lock file renamed `zane-lock.coda`, the manifest field that says whether a project is a library or an application, and the `zane` command that launches the pinned compiler without being pinned itself |
-| [`stories/memory.md`](stories/memory.md) | [`spec/memory.md`](spec/memory.md) — the no-GC-no-lifetimes goal, the move problem and the anchor, lazy backpointer creation, the indexed heap table, the rooted-guest rules and the host/guest terminology split, the collapse to one value/reference axis with a borrowed subject, the shift to segmented chunked bump arenas, the split into fixed-size and dynamic regions with anchors moved to a runtime-global recyclable pool, taking the bare symbol away as a guest source, the three passing modes that split out of it, giving both back when the ban cost more than the question it closed, and the dynamic region taking the boxes, each asking for exactly its own size, once recursion became hosting, and what a copy is for — the deep value copy that lets a value type recurse, and the reference-field ban that survived it, and the stable-place boundary that excludes subscripted paths and variant payloads from guest sources, and same-owner floating when contingent hosts disappear, what a move does to guests of the moved struct's fields, strings keeping their dynamic bytes without reference identity, the settled/roaming split that stopped guestable hosts from moving, the borrow returning as the bare spelling of a reference parameter, guests becoming plain offsets once anchors, backpointers and forwarders had nothing left to do, settled overwrites staying in place with only an escape relocating, and `ArrayRef` giving many settled objects a home |
+| [`stories/memory.md`](stories/memory.md) | [`spec/memory.md`](spec/memory.md) — the no-GC-no-lifetimes goal, the move problem and the anchor, lazy backpointer creation, the indexed heap table, the rooted-guest rules and the host/guest terminology split, the collapse to one value/reference axis with a borrowed subject, the shift to segmented chunked bump arenas, the split into fixed-size and dynamic regions with anchors moved to a runtime-global recyclable pool, taking the bare symbol away as a guest source, the three passing modes that split out of it, giving both back when the ban cost more than the question it closed, and the dynamic region taking the boxes, each asking for exactly its own size, once recursion became hosting, and what a copy is for — the deep value copy that lets a value type recurse, and the reference-field ban that survived it, and the stable-place boundary that excludes subscripted paths and variant payloads from guest sources, and same-owner floating when contingent hosts disappear, what a move does to guests of the moved struct's fields, strings keeping their dynamic bytes without reference identity, the settled/roaming split that stopped guestable hosts from moving, the borrow returning as the bare spelling of a reference parameter, guests becoming plain offsets once anchors, backpointers and forwarders had nothing left to do, settled overwrites staying in place with only an escape relocating, and `ArrayRef` giving many settled objects a home, and dropping the verbless `guest` for `reference` and `host` for `owner`, with the store rule's lifetime becoming the `scope` |
 | [`stories/lifetimes.md`](stories/lifetimes.md) | [`spec/lifetimes.md`](spec/lifetimes.md) — lexical scope in place of a borrow checker, what may be moved, the declaration-block rule that kills flow analysis, downgrade instead of use-after-move, parameter-rooted returned guests, why each strict rule is the minimal guard against one specific memory corruption, narrowing a returned guest's root to a guest parameter once borrows arrived, the root rule going back to "any parameter" once they left, the scope check that fired once at wiring and could be outrun by a later move, and the two lifetimes hiding behind that fix — a block and a hosting tree — which collapsed the raise enumeration into one owner comparison made at every store, paid for with a signature that records where a parameter comes to rest — and the stricter `init`-as-empty-template design that would have needed no signatures at all, kept on record with the two costs that turned it down, and the later distinction between an owner's lifetime and an interior place stable enough to originate a guest, plus same-owner floating when that contingent place disappears, and a moved host becoming spent rather than a guest, the three contradictions found by running the examples as compiler tests, and the parameter that lived at the call site going away once nothing guested could move |
 | [`stories/effects.md`](stories/effects.md) | [`spec/effects.md`](spec/effects.md) — inferring effects instead of annotating them, subject-scoped `mut`, capabilities in place of ambient I/O, the four-level ladder and the Total-Pure/Pure split, what deliberately is not an effect, and mutation through a borrowed subject, and where the first capability comes from: the runtime and console as objects only the root package reaches, and a mutating call as a write, which retired the four-level ladder |
 | [`stories/concurrency.md`](stories/concurrency.md) | [`spec/concurrency.md`](spec/concurrency.md) — the parallelism/concurrency split and the refusal of `async` coloring, why `spawn` marks only a call, water-tower lifetimes, signature-based safety without locks, value-typed mutation closing the aliased-write gap, and the two safety rules that turned out to enforce less than they claimed |