Offer the easings of an animation key on Lerp and sound FX ramps

A timed Set sound FX parameters ran only linearly, and a Lerp had four
quadratic eases of its own. An animation key already had the full set.
Now all three offer the same choice: Linear, Step, the ten curves from
Sine to Bounce with In, Out or In-out, and a drawn Curve asset.

- easingParams in src/core/graph/nodes/easing.ts gives a node the
  fields Easing, Direction and Curve from the key's own lists, and
  easingOfParams reads them back as a key interpolation.
- There is no migration. A Lerp saved with the old in, out or inOut
  runs linear until its easing is picked again.
- Set sound FX parameters hands the easing to the player. Linear and
  Step stay ramps of the audio clock, every other easing goes to
  setValueCurveAtTime as 200 samples a second, in semitones and dB.
- Step now reaches its end at t 1. A key never asked for that, it
  reads the next key itself, so animations play as before.
- The curve-in-use count and the warning for a gone curve cover the
  sound node too.

Tests:
- node-catalog: Lerp with cubic in, quad out and in-out, a curve
  without a direction, step, an unknown easing as linear. The sound
  node hands on a curve, step and a gone curve as linear.
- sound-library: an eased change becomes a curve in semitones and
  decibels, a step a jump at the end.
- node-catalog and curve after dropping the old values: 399, green.
- e2e 6, 34, 53 on melektaus-atx: ALL PASSED, 198 checks. In Chrome a
  2 s Quad in from depth 7 to -5 read speed 0.864 early and 0.5 at the
  end, a 1 s Step held 1 and then jumped to 0.5.
- Counter-check: with curves sent as linear ramps, the curve test of
  the sound library fails.

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

src/core/graph/nodes/data/Lerp.ts

@@ -1,60 +1,27 @@
-import type { GraphNode } from '../../Graph';
-import type { GraphLookup } from '../../lookup';
 import type { NodeDef } from '../../NodeRegistry';
 import { asNumber } from '../../values';
+import { curvesOf, easingOfParams, easingParams, hiddenEasing } from '../easing';
 import { num, withDefault } from '../shared';
 
-import { curveValue, LERP, LERP_CURVE } from '../../../model/curve';
-import { textOf } from '../../../model/Properties';
-
-/** Quadratic curves over t in 0…1, each running from 0 to 1. */
-const EASES: Record<string, (t: number) => number> = {
-  linear: (t) => t,
-  in: (t) => t * t,
-  out: (t) => 1 - (1 - t) * (1 - t),
-  inOut: (t) => (t < 0.5 ? 2 * t * t : 1 - 2 * (1 - t) * (1 - t)),
-};
+import { easedShare } from '../../../model/animation';
+import { LERP } from '../../../model/curve';
 
 export const Lerp: NodeDef = {
   type: LERP,
   label: 'Lerp',
   category: 'data',
   description:
-    'Blends from a to b as t runs from 0 to 1, along the chosen ease. t is held in 0…1. With Ease ' +
-    'set to Curve it follows the Curve asset picked below, and may overshoot b.',
+    'Blends from a to b as t runs from 0 to 1, along the chosen easing – the same ones an animation ' +
+    'key offers. t is held in 0…1. Step stays at a until t reaches 1. Back, Elastic and a Curve ' +
+    'asset may overshoot b.',
   inputs: [withDefault(num('a'), 0), withDefault(num('b'), 1), withDefault(num('t'), 0)],
   outputs: [num('result')],
-  params: [
-    {
-      key: 'ease',
-      label: 'Ease',
-      kind: 'enum',
-      default: 'linear',
-      options: [
-        { value: 'linear', label: 'Linear' },
-        { value: 'in', label: 'In' },
-        { value: 'out', label: 'Out' },
-        { value: 'inOut', label: 'In-out' },
-        { value: 'curve', label: 'Curve' },
-      ],
-    },
-    { key: LERP_CURVE, label: 'Curve', kind: 'asset', default: '', assetTypes: ['curve'] },
-  ],
-  hiddenParams: (params) => (textOf(params.ease) === 'curve' ? [] : [LERP_CURVE]),
+  params: easingParams(),
+  hiddenParams: hiddenEasing,
   run: (_ctx, inputs, params, _def, _entry, lookup) => {
     const a = asNumber(inputs.a);
     const t = Math.min(Math.max(asNumber(inputs.t), 0), 1);
-    const ease = textOf(params.ease);
-    const points = ease === 'curve' ? lookup.curve(textOf(params[LERP_CURVE] ?? '')) : null;
-    const share = points ? curveValue(points, t) : (EASES[ease] ?? EASES.linear!)(t);
+    const share = easedShare(easingOfParams(params), t, curvesOf(lookup));
     return { outputs: { result: a + (asNumber(inputs.b) - a) * share } };
   },
 };
-
-/** Why a Lerp set to Curve runs linear instead, or null when it eases as it says. */
-export function lerpProblem(node: GraphNode, lookup: GraphLookup): string | null {
-  if (node.type !== LERP || textOf(node.params.ease) !== 'curve') return null;
-  const id = textOf(node.params[LERP_CURVE] ?? '');
-  if (!id) return 'No curve picked – runs linear';
-  return lookup.curve(id) ? null : 'That curve is gone – runs linear';
-}