feat: grow memory limits, add icon/actor libraries, overhaul LSP diagnostics

Compiler and VM
- make every memory map limit dynamic and adjustable at both build time and
  runtime, including compiler tables, stacks, and every execution region
- reserve and grow tables, operand and return stacks, frame segments, and
  image-building output without relocating live code or globals
- rename i/o and string helpers consistently (puts -> put_s, putn -> put_n,
  scat -> cat_s) across compiler, runtime, examples, tests, and docs
- recast and consume values assigned to globals from inside functions
- allow fixed and const together, add typed closure returns (fn:t(...)),
  multi-include syntax (include rt, run, core;), and recurse type inference
- never infer string literals as word, anywhere, as argument, variable, or
  return type
- draft docs/BORROW.md: a borrow checker less intrusive than Rust's but more
  intelligent

LSP and editor integration
- require explicit includes and give every toolchain area its own namespace
  (rt, lsp, run, core)
- hover for built-in types, inferred types, values known at hover time, array
  and pointer lifetime/size, library names in include statements, and inferred
  lifetimes with explanations
- honor /* */ comments as documentation for variables and arguments, and stop
  misattributing section headers or trailing comments as variable hints
- stream diagnostics and cancel stale requests on change
- jump to definition and references, including cross-file
- quick fixes with automatic library import, and namespace completion

Hints and diagnostics
- render hints as blue squigglies by default, with hints on/small/off per file
- suppress magic-number hints via a preceding /* */ comment, and say so
- warn on unused arguments; allow multiple _ discards in parameters, pattern
  matching, and tagged enums, warning if a _ is actually used
- rewrite hint and comment prose in professional compiler-doc register

Libraries
- add icon.zc: run-time self-modification, find/replace syntax, type and block
  edits, and step-through inspection of locals and globals
- add actor.zc: async actors with Actor<I,O>, implicit this, spawn/recv/send,
  injected into the compiler machinery at include time rather than built in

Tooling and docs
- reorganize sources, tests, and designs into subdirectories
- unify windows entry points in tinyvm.bat and add a matching tinyvm.sh
- add --help across the toolchain
- polish the learning guide, stdlib docs, and design notes

Tests
- add accept, reject, and regression coverage across the compiler, LSP,
- runtime, icon, actors, threads, formatting, and the toolchain contracts,
  plus fuzzers and property tests

1 files changed, 55 insertions, 0 deletions

diff --git a/tests/drivers/stream_test.js b/tests/drivers/stream_test.js
new file mode 100644
index 0000000..e783862
--- /dev/null
+++ b/tests/drivers/stream_test.js
@@ -0,0 +1,55 @@
+// large checks stream partial diagnostics, and a check is dropped when newer input is already waiting.
+// usage: node tests/drivers/stream_test.js path/to/zclsp
+const assert = require('assert');
+const cp = require('child_process');
+const server = process.argv[2];
+const frame = m => { const b = Buffer.from(JSON.stringify(m)); return Buffer.concat([Buffer.from('Content-Length: ' + b.length + '\r\n\r\n'), b]); };
+const doc = (n, tail) => { let t = ''; for (let i = 0; i < n; i++) t += `int f${i}(int a) { return a + ${i}; }\n`; return t + tail; };
+function messages(out) {
+    const res = [];
+    let d = out;
+    while (d.length) {
+        const e = d.indexOf('\r\n\r\n'), n = Number(/Content-Length:\s*(\d+)/i.exec(d.subarray(0, e).toString())[1]);
+        res.push(JSON.parse(d.subarray(e + 4, e + 4 + n))); d = d.subarray(e + 4 + n);
+    }
+    return res;
+}
+const published = (msgs, uri) => msgs.filter(m => m.method === 'textDocument/publishDiagnostics' && m.params.uri === uri);
+// spawn the server and write each step after the previous one has had time to run (delay in ms)
+function session(steps) {
+    return new Promise(resolve => {
+        const p = cp.spawn(server, process.argv.slice(3));
+        let out = Buffer.alloc(0);
+        p.stdout.on('data', c => { out = Buffer.concat([out, c]); });
+        p.on('exit', () => resolve(messages(out)));
+        let at = 0;
+        const next = () => {
+            if (at >= steps.length) { p.stdin.write(frame({ jsonrpc: '2.0', method: 'exit' })); return; }
+            const [delay, msgs] = steps[at++];
+            p.stdin.write(Buffer.concat(msgs.map(frame)));
+            setTimeout(next, delay);
+        };
+        next();
+    });
+}
+const init = { jsonrpc: '2.0', id: 1, method: 'initialize', params: {} };
+const open = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didOpen', params: { textDocument: { uri, version, languageId: 'zc', text } } });
+const change = (uri, version, text) => ({ jsonrpc: '2.0', method: 'textDocument/didChange', params: { textDocument: { uri, version }, contentChanges: [{ text }] } });
+(async () => {
+    const A = 'file:///stream.zc';
+    // a large document with an error at the top: partial lists arrive before the end, the last holds everything
+    const bad = 'int broken( { }\n' + doc(1500, 'fn main() { return f0(1); }\n');
+    let msgs = published(await session([[3000, [init, open(A, 1, bad)]]]), A);
+    assert.ok(msgs.length >= 2, 'a large check streams several lists: ' + msgs.length);
+    assert.ok(msgs[0].params.diagnostics.some(d => d.severity === 1), 'the first list already has the error');
+    assert.ok(msgs[msgs.length - 1].params.diagnostics.length >= msgs[0].params.diagnostics.length, 'later lists grow');
+    // a change that is already waiting drops the stale check: only the newer version is published
+    const ok = doc(1500, 'fn main() { return f0(1); }\n');
+    msgs = published(await session([[3000, [init, open(A, 1, ok), change(A, 2, 'fn main() { return 0; }\n')]]]), A);
+    assert.ok(msgs.length >= 1 && msgs.every(m => m.params.version === 2), 'the stale version 1 is never published: ' + JSON.stringify(msgs.map(m => m.params.version)));
+    // an interrupted open of another document is still answered once nothing newer waits
+    const B = 'file:///other.zc';
+    msgs = await session([[3000, [init, open(A, 1, ok), open(B, 1, 'fn main() { return 0; }\n')]]]);
+    assert.ok(published(msgs, A).length >= 1 && published(msgs, B).length >= 1, 'both documents are published');
+    console.log('ok   large checks stream partial diagnostics and drop stale checks');
+})();