fix(core): unpause timelines nested into the registered root

[miguel-heygen]

What

Timelines nested into the registered root are unpaused before anything reads the root's
duration, so a composition built from paused scene timelines renders instead of coming out
black.

Closes #3419.

Why

A scene timeline authored as gsap.timeline({ paused: true }) and nested with .add()
keeps its own playhead frozen. Seeking the root never advances it, the root reads
duration() as 0, and every captured frame renders the t=0 state. The output is an entirely
black video, and lint, check and validate all pass, because none of them looks at
pixels.

The trap is that our own contract invites it. We ask for the registered root to be paused
so the renderer owns the playhead. Applying that to scene timelines too is the natural
misreading:

const bg   = gsap.timeline({ paused: true });   // scene 1
const text = gsap.timeline({ paused: true });   // scene 2
const master = gsap.timeline({ paused: true });
master.add(bg, 0).add(text, 3);
window.__timelines["main"] = master;            // black video, zero warnings

Investigation

Not a GSAP regression. Measured identical on every version back to 3.11.5:

gsap	3.11.5	3.12.5	3.13.0	3.14.0	3.14.2	3.15.0
parent.duration()	0	0	0	0	0	0

Not shipped breakage. Nothing in registry/ nests a paused timeline.

The framework already solved this for the neighbouring path.
ensureChildCandidatesActive (init.ts) has been calling paused(false) on child timelines
all along — but it finds them via collectRootChildCandidates, which walks
[data-composition-id] nodes and looks up timelines[childId]. That is the sub-composition
path. Timelines combined by hand are never registered under a composition id, so the
collector cannot see them.

How

One helper, called the moment the root timeline is resolved.

Placement is load-bearing and was the subtle part. Reading duration() while a child is
still paused caches 0 on the parent permanently — invalidate() does not clear it:

sequence	result
unpause, then read duration	dur=6, renders
read duration, then unpause	dur=0, still black
read duration, unpause, then invalidate()	dur=0, still black

So the unpause runs before anything can touch the root's duration. nested:false keeps it
to one level: a grandchild belongs to its own parent's playhead, which the same pass fixes
when that parent is reached.

Test plan

End to end, at the pixel level, on the reported pattern — two paused scene timelines
added to a paused master, 6s at 30fps. Frame 150 sampled with ffmpeg:

	frame 150 RGB	file
hyperframes@0.8.10	000000 (black)	7.1 KB
this branch	71ae31 (content)	17.7 KB

Unit test in init.test.ts asserts a nested paused child ends up unpaused after init.
Verified it fails on the unfixed code rather than assuming:

× initSandboxRuntimeModular > unpauses timelines nested into the registered root
  → expected true to be false

Full packages/core suite green: 2491 passed.

Not covered

• The contract wording still says "GSAP timelines must be paused", which is what invites the
  misreading. Saying the registered root would prevent it at the source. Left out of this
  PR because it touches skills and docs surfaces that need their own sync.
• No lint rule. The runtime fix cannot be evaded, including by timelines assembled
  dynamically, so a static rule would only duplicate it for the subset it can see.