Fix nested-effect cleanup order and add LIFO disposal

[johnsoncodehk]

Summary

Two bugs in cleanup of nested effects:

1. Inner cleanup never ran on auto-dispose. When an inner effect was disposed by the parent re-running or being disposed (rather than by the user calling its own dispose function), unwatched routed it straight to effectScopeOper, which only clears state — .cleanup was never read. Inner cleanup was silently dropped on every auto-dispose path.

2. Order was inverted. Even with cleanup hooked into auto-dispose, the parent's own cleanup ran first; children were disposed afterwards via purgeDeps. Standard reverse-of-creation order requires:

   • Inner cleanup before outer cleanup (so the inner can still rely on whatever state the outer set up).
   • Old inner cleanup before the body re-runs (so it doesn't clean up state the new inner already set up).

Changes

Routing — unwatched dispatches by node shape

unwatched(node) {
  if ('fn' in node) effectOper.call(node);          // EffectNode → full dispose
  else if ('getter' in node) { /* stale clear */ }  // ComputedNode
  else if ('currentValue' in node) { /* noop */ }   // SignalNode
  else effectScopeOper.call(node);                  // EffectScopeNode / trigger sub
}

Pre-walk children before own cleanup

effectOper, effectScopeOper, run(), and updateComputed all walk this.depsTail backward and unlink child EffectNode deps before the node's own cleanup runs. unlink triggers unwatched → recursive effectOper on each child, so grandchildren clean up depth-first reverse before their parent.

Fast path — HasChildEffect flag

A new bit defined locally in index.ts (outside ReactiveFlags' range so system.ts never touches it). effect() sets it on the parent when linking; run() and updateComputed check it before doing the pre-walk. Leaf effects with no child effects skip the walk entirely.

The flag is dynamic — it's cleared at the start of every body re-run and re-set if the body creates new children. So an effect that stops creating children moves back to the fast path automatically.

The else if branch of run() (the parent-chain-notify case where outer is queued but not dirty) explicitly preserves the flag: e.flags = Watching | (flags & HasChildEffect). Otherwise an inner-only re-run clobbers the outer's bit and the next real re-run skips the pre-walk.

Tests

tests/effect.spec.ts:

• cleanup order on outer re-run
• cleanup order on dispose
• sibling cleanup order (LIFO) on dispose / re-run
• three-level nested cleanup
• cleanup order after a prior inner-only re-run (regression for the bit-loss path)
• effect created inside computed (updateComputed regression)

tests/effectScope.spec.ts (new):

• scope dispose runs child cleanup
• sibling LIFO on scope dispose
• depth-first reverse for nested in scope

198 passing.

[bolt-new-by-stackblitz]

Run & review this pull request in StackBlitz Codeflow.