Trim needless comments and fix the picker width

Remove comments that only restate the code, keeping the section banners
and the notes that carry a reason, a measured fact or an external
contract.

ButtonOptions.width claimed to be a fixed width but only set minWidth,
so the Graph and Texture pickers grew with the name they showed. It is
now what it promises, with a separate minWidth for the buttons that have
two forms. Narrow buttons shrink their padding, otherwise a 24px icon
button had 8px left for its glyph and truncate dropped it entirely.

__gm.labelsDropped() guards that class: the overflow guard only saw text
that was too wide, never a label truncated to nothing.

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

src/core/graph/GraphInterpreter.ts

@@ -10,21 +10,17 @@ import type { Value } from './values';
 const MAX_STEPS_PER_FIRE = 1000;
 
 export interface TraceListener {
-  /** An exec edge was followed. */
   onEdge(edgeId: string): void;
-  /** A node ran (exec) or was evaluated (data). */
   onNode(nodeId: string): void;
 }
 
 /**
- * Runs one behavior graph for one instance. Blueprint semantics: an event node starts a
- * *pulse*; the interpreter follows exec edges, and whenever a node needs a data input it
- * pulls the value from the connected output – evaluating pure data nodes lazily and
- * reading exec nodes' outputs from the pulse cache. Per-node state (timers) lives here,
- * so every instance has its own.
+ * Runs one behavior graph for one instance. An event node starts a *pulse*; the interpreter follows
+ * exec edges and pulls data inputs from the connected output, evaluating pure data nodes lazily and
+ * reading exec nodes' outputs from the pulse cache.
  */
 export class GraphInterpreter {
-  /** Per-node persistent state across pulses (timer accumulators etc.). */
+  /** Per-node state that persists across pulses (timer accumulators etc.). */
   readonly nodeState = new Map<string, Record<string, number>>();
   private outputCache = new Map<string, Record<string, Value>>();
   private steps = 0;
@@ -32,15 +28,11 @@ export class GraphInterpreter {
 
   constructor(readonly graph: Graph) {}
 
-  /** Nodes of one event type, in graph order. */
   eventNodes(type: string): GraphNode[] {
     return this.graph.nodes.filter((n) => n.type === type);
   }
 
-  /**
-   * Fires every event node of `type` whose params satisfy `filter`, seeding its outputs with
-   * `outputs` (e.g. `{ dt }`). Returns how many event nodes fired.
-   */
+  /** Fires every event node of `type` passing `filter`, seeding its outputs with `outputs`. */
   fire(
     type: string,
     ctx: NodeContext,
@@ -60,7 +52,6 @@ export class GraphInterpreter {
     return fired;
   }
 
-  /** Follows the exec edges leaving `port` of `node`, running each target in order. */
   private follow(node: GraphNode, port: string, ctx: NodeContext): void {
     for (const edge of edgesOutOf(this.graph, node.id, port)) {
       const target = this.node(edge.to.node);