Add full compiler toolchain, libc, examples and reference docs

First substantive commit: the entire Sprinter C compiler tree on top of
the bare README+gitignore initial commit.

What's in here:
  bin/sprinter-cc        — driver script invoking SDCC + linker + mkexe
  libc/                  — Sprinter-specific libc layer over ESTEX/BIOS
                           (conio, gfx, io, mem, stdio + headers)
  runtime/               — crt0 variants (default/small/banked/minimal)
                           + heap + bank trampolines
  toolchain/             — mkexe (SprintEXE packer, C + tests)
  examples/              — 30 demo programs (gfx, file I/O, env, time, …)
  lib/Makefile           — builds the libc archive (sprinter.lib)
  docs/                  — converted Sprinter manuals + asm reference samples
  third_party/           — solid-c reference compiler dump + sdcc setup script
  release_docs/          — packaging / release notes

gitignore overhaul:
  • Drop dangerous blanket patterns: *.asm (would hide docs/samples/*.asm)
    and *.exe (case-insensitive match was hiding third_party/solid-c/*.EXE
    on macOS APFS).  Replaced with examples/*/*.{asm,exe,…} and lib/*.lib.
  • Restore tracking of toolchain/mkexe/tests/{one,big}.bin — those are
    INPUT fixtures, not build outputs.
  • Collapse the duplicated SDCC/C/Sdcc sections into one section per
    concern (build outputs / vendored / OS-junk).
  • Add .sprinter-cc-*/, build/ (catches lib/build/ too), .claude/.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

examples/gfx_dbuf/Makefile

@@ -0,0 +1,3 @@
+PROJ_ROOT := $(abspath $(CURDIR)/../..)
+EXAMPLE   := gfx_dbuf
+include $(PROJ_ROOT)/examples/example.mk

examples/gfx_dbuf/gfx_dbuf.c

@@ -0,0 +1,120 @@
+/*
+ * gfx_dbuf — double-buffering demo.
+ *
+ * Renders a moving rectangle by alternating between page 0 and page 1:
+ *   - Each frame: draw to the HIDDEN page, then flip visible to it.
+ *   - The page currently being displayed is never written to, so the
+ *     user only sees fully-rendered frames (no half-drawn artefacts,
+ *     no flicker from the per-frame clear).
+ *
+ * Indicators help verify the swap is actually happening:
+ *   - A small colour swatch in the top-right alternates each frame:
+ *     one shade when page 0 is shown, another when page 1.  If the
+ *     box motion looks smooth and the swatch flickers between the two
+ *     shades at the animation rate, the swap is working.
+ *
+ * NOTE: each graphics screen has its OWN palette page (screen 0 →
+ * palette 0, screen 1 → palette 1).  We load the same palette into
+ * both so the colours look identical regardless of which page is
+ * currently visible.  See memory/sprinter_graphics.md.
+ *
+ * Press any key to exit.
+ */
+
+#include <stdio.h>
+#include <conio.h>
+#include <gfx.h>
+#include <stdint.h>
+
+static uint8_t palette[256 * 4];
+
+#define COL_BLACK   0x00
+#define COL_BG      0x20
+#define COL_STRIPE  0x60
+#define COL_TEXT    0xC0
+#define COL_BOX     0xFF
+#define COL_PAGE0   0x40
+#define COL_PAGE1   0xE0
+
+static void make_palette(void)
+{
+    for (int i = 0; i < 256; i++) {
+        palette[i*4+0] = (uint8_t)i;
+        palette[i*4+1] = (uint8_t)i;
+        palette[i*4+2] = (uint8_t)i;
+        palette[i*4+3] = 0;
+    }
+}
+
+static void draw_frame(int box_x, int box_y, uint8_t page_indicator)
+{
+    gfx_clear256(COL_BG);
+
+    /* Static decoration — identical on both pages so the swap doesn't
+     * flicker the chrome. */
+    gfx_fill_rect256(0, 0,              GFX_WIDTH, 8, COL_STRIPE);
+    gfx_fill_rect256(0, GFX_HEIGHT - 8, GFX_WIDTH, 8, COL_STRIPE);
+
+    gfx_text256(8, 16, "double-buffering demo", COL_TEXT, COL_BG);
+    gfx_text256(8, GFX_HEIGHT - 24,
+             "press a key to exit", COL_TEXT, COL_BG);
+
+    /* Page indicator — different shade for each page so a flickering
+     * box here proves the swap is happening. */
+    gfx_fill_rect256(GFX_WIDTH - 24, 16, 12, 12,
+                  page_indicator ? COL_PAGE1 : COL_PAGE0);
+
+    /* The animated box. */
+    gfx_fill_rect256(box_x, box_y, 40, 30, COL_BOX);
+    gfx_rect256    (box_x, box_y, 40, 30, COL_BLACK);
+}
+
+int main(void)
+{
+    make_palette();
+    uint8_t prev = gfx_init(GFX_MODE_320x256x256, 0);
+
+    /* Each graphics screen has its own palette page (0→pal 0, 1→pal 1).
+     * Load the same data into both so the visual swap is seamless. */
+    gfx_pal_load(0, 0, 0, palette);
+    gfx_pal_load(1, 0, 0, palette);
+
+    /* Clear both pages so the very first flip doesn't reveal garbage. */
+    gfx_set_draw_page(0);
+    gfx_clear256(COL_BG);
+    gfx_set_draw_page(1);
+    gfx_clear256(COL_BG);
+
+    /* Bouncing rect state. */
+    int box_x  = 10;
+    int box_y  = 100;
+    int dx     = 3;
+    int dy     = 2;
+    const int box_w = 40, box_h = 30;
+
+    while (!kbhit()) {
+        uint8_t hidden = 1 - gfx_get_visible_page();
+        gfx_set_draw_page(hidden);
+
+        draw_frame(box_x, box_y, hidden);
+
+        /* Wait for the next frame interrupt before flipping, so the
+         * page swap lands during vertical retrace and the user never
+         * sees a half-drawn frame. */
+        gfx_wait_vsync();
+        gfx_set_visible_page(hidden);
+
+        /* Step the box; bounce off all four walls. */
+        box_x += dx;
+        if (box_x < 0)                    { box_x = 0;                    dx = -dx; }
+        if (box_x + box_w > GFX_WIDTH)    { box_x = GFX_WIDTH  - box_w;   dx = -dx; }
+        box_y += dy;
+        if (box_y < 8)                    { box_y = 8;                    dy = -dy; }
+        if (box_y + box_h > GFX_HEIGHT-8) { box_y = GFX_HEIGHT-8 - box_h; dy = -dy; }
+    }
+
+    (void)getch();
+    gfx_done(prev);
+    puts("done");
+    return 0;
+}