feat(highway): render teaching marks fg/ch/sd on 2D + 3D (§6.2.2) (#538)

Render the three per-note teaching marks on both highways, mirroring the
bend-curve render (#532). Display only — no scoring / NoteVerifier coupling.

- 2D static/highway.js: fg renders by default as a small finger numeral hugging
  the gem (T = thumb, 1..4); sd (degree label) and ch (strum bracket connecting
  notes that share a ch key, arrow direction from pkd) are opt-in behind a new
  `showTeachingMarks` toggle (exposed via toggle/get/set + the bundle's
  `teachingMarksVisible` flag). Pure helpers teachingFingerLabel /
  teachingDegreeLabel / strumGroupBuckets drive the glyphs. ch bracket is
  note-stream-only (chord notes already read as one gesture).
- 3D plugins/highway_3d/screen.js: fg (default) + sd (opt-in, mirrors the 2D
  toggle via bundle.teachingMarksVisible) render next to the per-note fret label
  via a new pooled sprite (pTeachMarkLbl); _scrChordNote resets fg/sd so chord
  notes don't inherit stale marks. ch strum brackets are deferred in 3D (no
  cross-note batch pass in the per-note render); 2D covers ch.

Tests: tests/js/highway_teaching_marks.test.js extracts the pure helpers from
both files (extract-and-eval) and asserts label mapping + strum-group bucketing.

Part of got-feedback/feedback#334

Co-authored-by: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

tests/js/highway_teaching_marks.test.js

@@ -0,0 +1,92 @@
+// Behavioural tests for the teaching-marks (§6.2.2) render helpers:
+// teachingFingerLabel / teachingDegreeLabel (both highways) and
+// strumGroupBuckets (2D, drives the strum bracket). All pure, so we extract
+// the function source by brace-matching and eval it in isolation — same
+// pattern as highway_bend_curve.test.js.
+
+const { test } = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+
+function extractFn(src, name) {
+    const start = src.indexOf('function ' + name);
+    assert.ok(start >= 0, `function ${name} must exist`);
+    const open = src.indexOf('{', start);
+    let depth = 0;
+    for (let i = open; i < src.length; i++) {
+        if (src[i] === '{') depth++;
+        else if (src[i] === '}' && --depth === 0) return src.slice(start, i + 1);
+    }
+    throw new Error(`unbalanced braces extracting ${name}`);
+}
+
+function loadFn(file, name) {
+    const src = fs.readFileSync(path.join(__dirname, '..', '..', file), 'utf8');
+    return new Function('"use strict";' + extractFn(src, name) + `\nreturn ${name};`)();
+}
+
+const fingerLabel2D = loadFn('static/highway.js', 'teachingFingerLabel');
+const degreeLabel2D = loadFn('static/highway.js', 'teachingDegreeLabel');
+const fingerLabel3D = loadFn('plugins/highway_3d/screen.js', 'teachingFingerLabel');
+const degreeLabel3D = loadFn('plugins/highway_3d/screen.js', 'teachingDegreeLabel');
+const strumGroupBuckets = loadFn('static/highway.js', 'strumGroupBuckets');
+
+// ── teachingFingerLabel (fg) ─────────────────────────────────────────────────
+
+for (const [name, fn] of [['2D', fingerLabel2D], ['3D', fingerLabel3D]]) {
+    test(`teachingFingerLabel (${name}) maps 0->T, 1..4->digit, else ''`, () => {
+        assert.equal(fn(0), 'T');     // thumb
+        assert.equal(fn(1), '1');
+        assert.equal(fn(4), '4');     // pinky
+        assert.equal(fn(-1), '');     // unset
+        assert.equal(fn(5), '');      // out of range
+        assert.equal(fn(1.5), '');    // non-integer
+        assert.equal(fn(undefined), '');
+        assert.equal(fn(null), '');
+    });
+}
+
+// ── teachingDegreeLabel (sd) ─────────────────────────────────────────────────
+
+for (const [name, fn] of [['2D', degreeLabel2D], ['3D', degreeLabel3D]]) {
+    test(`teachingDegreeLabel (${name}) shows 0..11, else ''`, () => {
+        assert.equal(fn(0), '0');     // tonic
+        assert.equal(fn(7), '7');     // fifth
+        assert.equal(fn(11), '11');
+        assert.equal(fn(-1), '');     // unset
+        assert.equal(fn(12), '');     // out of range
+        assert.equal(fn(3.2), '');    // non-integer
+        assert.equal(fn(undefined), '');
+    });
+}
+
+// ── strumGroupBuckets (ch) ───────────────────────────────────────────────────
+
+test('strumGroupBuckets groups notes sharing a ch >= 0, dropping lone notes', () => {
+    const items = [
+        { id: 'a', ch: 5 },
+        { id: 'b', ch: -1 },   // ungrouped
+        { id: 'c', ch: 5 },
+        { id: 'd', ch: 7 },    // lone group (only one member) -> dropped
+        { id: 'e', ch: 5 },
+    ];
+    const groups = strumGroupBuckets(items);
+    assert.equal(groups.length, 1);
+    assert.deepEqual(groups[0].map(n => n.id), ['a', 'c', 'e']);
+});
+
+test('strumGroupBuckets preserves first-seen group order and handles multiple groups', () => {
+    const items = [
+        { id: 'a', ch: 2 }, { id: 'b', ch: 9 },
+        { id: 'c', ch: 2 }, { id: 'd', ch: 9 },
+    ];
+    const groups = strumGroupBuckets(items);
+    assert.deepEqual(groups.map(g => g.map(n => n.id)), [['a', 'c'], ['b', 'd']]);
+});
+
+test('strumGroupBuckets ignores non-integer / negative ch and bad input', () => {
+    assert.deepEqual(strumGroupBuckets([{ ch: -1 }, { ch: 1.5 }, { ch: null }, {}]), []);
+    assert.deepEqual(strumGroupBuckets([]), []);
+    assert.deepEqual(strumGroupBuckets(null), []);
+});