libc/kbd: held-карта клавиш в биты (512 -> 64 Б); эталон размеров принят

Разгрузка W1/W2 под будущий ИИ стражей: _kbdraw_down был БАЙТОМ на
скан-код (512 Б в _DATA при 32-килобайтной раскладке).  Теперь бит на
код: код>>3 = байт, код&7 = бит, расширенные (префикс 0xE0) — смещение
+32 байта вместо +256.

Трамплин прерывания строит маску СДВИГОМ, а не таблицей: таблица
потребовала бы `ld hl,#метка` внутри трамплина, а он копируется в W2
побайтно и обязан быть без абсолютных само-ссылок (см. его шапку).
Маска строится в BC, поэтому в клавиатурной ветке добавлен push/pop bc.
Трамплин вырос 244 -> 267 Б, буфер копии поднят 320 -> 336 (запас 69 Б).

Проверено в MAME на roomtest, все три класса клавиш:
  - обычные: '=' (обход комнат) и 'K' (чит-убийство стража — читал
    guardhp_curr/delta: 3/0 -> 0/-3);
  - расширенные (E0): стрелка вправо — Kid добежал до края комнаты;
  - модификаторы: удержание Shift ставит бит 2 байта 2 карты
    (скан-код 0x12), отпускание снимает.

Скорость: кадр 334 716 -> 338 508 тактов (+1.1 %) на битовой арифметике
в kbd_raw_down (~15 вызовов за кадр); при бюджете 430 000 это 0.79
периода вместо 0.78 — регрессии нет.

Итог по roomtest: данные 4422 -> 4022 Б, куча W2 996 -> 1294 Б.

Эталон размеров принят заново (make size-baseline): _CODE десяти
программ вырос на 14-23 Б — это код битовой арифметики в трамплине и
kbd_raw_down, обмен на -448 Б данных, которые size_check не считает.

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

libc/kbd/_kbdraw.h

@@ -23,7 +23,12 @@ extern uint8_t _kbdraw_pending;     /* FSM декодера make/break, см. в
 extern uint8_t _kbdraw_overrun;     /* 1 = ISR поймал Rx-overrun SIO (потерян
                                       * байт → возможно потерян break); снимает
                                       * kbd_raw_sync (чистит _kbdraw_down) */
-extern uint8_t _kbdraw_down[512];   /* 0/1 по коду; +256 для расширенных
-                                      * (префикс 0xE0) — см. kbd_raw_down */
+/* Held-состояние: БИТ на скан-код, код>>3 = байт, код&7 = номер бита;
+ * коды 0..255 обычные, 256..511 — расширенные (префикс 0xE0), т.е.
+ * смещение +32 байта.  Упаковка вместо байта на код: 64 Б вместо 512 —
+ * заметная доля _DATA на 32-килобайтной раскладке (замер PoP roomtest
+ * 2026-07-30).  Ведёт трамплин прерывания (libc/irq/_irq_tramp.c),
+ * читает kbd_raw_down(). */
+extern uint8_t _kbdraw_down[64];
 
 #endif

libc/kbd/_kbdraw_state.c

@@ -9,4 +9,4 @@ uint8_t _kbdraw_active;
 uint8_t _kbdraw_pending;
 uint8_t _kbdraw_overrun;            /* ISR взвёл при Rx-overrun SIO (потерян
                                      * break) — kbd_raw_sync снимет залипшее */
-uint8_t _kbdraw_down[512];
+uint8_t _kbdraw_down[64];           /* БИТ на скан-код (см. _kbdraw.h) */

libc/kbd/kbd_raw_down.c

@@ -10,5 +10,5 @@
 uint8_t kbd_raw_down(uint16_t code)
 {
     if (code >= 512) return 0;
-    return _kbdraw_down[code];
+    return (uint8_t)((_kbdraw_down[code >> 3] >> (code & 7)) & 1);
 }

libc/kbd/kbd_raw_sync.c

@@ -36,7 +36,15 @@ void kbd_raw_sync(void)
     if (!_kbdraw_overrun) return;
     _kbdraw_overrun = 0;
 
-    for (i = 0; i < 6; i++) save[i] = _kbdraw_down[_kbd_mod_codes[i]];
+    /* Карта упакована по битам (см. _kbdraw.h): сохраняем/возвращаем
+     * именно БИТ модификатора, а не байт. */
+    for (i = 0; i < 6; i++) {
+        uint16_t c = _kbd_mod_codes[i];
+        save[i] = (uint8_t)((_kbdraw_down[c >> 3] >> (c & 7)) & 1);
+    }
     memset(_kbdraw_down, 0, sizeof(_kbdraw_down));
-    for (i = 0; i < 6; i++) _kbdraw_down[_kbd_mod_codes[i]] = save[i];
+    for (i = 0; i < 6; i++) {
+        uint16_t c = _kbd_mod_codes[i];
+        if (save[i]) _kbdraw_down[c >> 3] |= (uint8_t)(1 << (c & 7));
+    }
 }