A particle is a function of its age, not a thing that is stepped (#73)

The asset type `particles` is placeable and carries a graph at the same time —
`behavior` was the blueprint. Because a continuous emitter gives birth to particle n
at time n/rate, the whole field is a function of the clock rather than of the frames:
no ring-buffer bookkeeping, exact time jumps, reproducibility as a measurable property.

compile.ts follows compileShader's frame but emits JS closures into a Float64Array
instead of GLSL, and without eval; a node with two consumers is evaluated once.
Drawing is one Pixi ParticleContainer per source, so one draw call.

Collision, wind and braking in flight are out for good — that is the price of the
formula model, not an omission.

The tab count goes from nine to ten, which is exactly the case #84 was built for one
day earlier: at 1280 px the row no longer holds every tab, so guard 14b now asks for
hidden.length > 0 instead of === 0.

tests/core/node-catalog.test.ts

@@ -56,6 +56,8 @@ const run = (type: string, c: Case): { result: RunResult; ctx: FakeContext } =>
 };
 
 const at = (name: string, x: number, y: number) => ({ ...fakeEntity(name), x, y });
+/** Its own entity, because Emit's whole effect is the count it leaves on the one it is handed. */
+const emitTarget = fakeEntity('Sparks');
 const painted = fakeHandle({ width: 100, text: '' });
 
 const pointer = (overrides: Partial<NodeContext['pointer']>): Partial<NodeContext> => ({
@@ -647,6 +649,19 @@ const CASES: Record<string, Case[]> = {
       next: 'exec',
     },
   ],
+  Emit: [
+    {
+      name: 'no source is a no-op that still continues the flow',
+      inputs: { source: null },
+      next: 'exec',
+    },
+    {
+      name: 'counts a pulse on the source it is given',
+      inputs: { source: emitTarget },
+      next: 'exec',
+      after: () => expect(emitTarget.emits).toBe(1),
+    },
+  ],
   Log: [
     {
       name: 'logs its message and continues',