Follow-up to #225. A self-review surfaced two test-quality issues in the
new race regression suite:

1. AnimationInvalidation_ConcurrentWithReplace_DoesNotThrow ordered
   Interlocked.Exchange AFTER node.Replace, so the ticker mostly read a
   reference to an already-disposed segment rather than racing a live one.
   The test mostly validated "TriggerInvalidation tolerates disposed
   segment" rather than the advertised live-vs-Replace race.

   Restructure: a permanently-tracked spinner is the ticker's target;
   Replace operates on a SEPARATE tracked element. The ticker is always
   firing on a live subscription, so OnAnimationInvalidated competes with
   Replace for _contentLock — which is the race the test claims to cover.

2. AnimationInvalidation_AfterDispose_DoesNotThrow passed for the wrong
   reason: node.Dispose() disposes the R3 subscription before the late
   TriggerInvalidation runs, so OnAnimationInvalidated is never invoked
   and the _disposed flag's belt-and-suspenders role is not exercised.

   Keep the original test (rebranded — it does validate subscription
   teardown, a legitimate concern) and add a new reflection-based test
   that invokes OnAnimationInvalidated directly after Dispose. Verified
   the new test FAILS with ObjectDisposedException from R3.Subject.OnNext
   when the `_disposed` guard is removed, and PASSES when the guard is
   present — so it actually catches the regression.

Final follow-up from the PR #225 self-review. Pre-existing latent race:
public mutators (Append, AppendLine, AppendTracked, Remove, Replace, Clear,
ScrollUp/Down/ToBottom) all end with NotifyChanged() → _invalidated.OnNext.
The mutator releases _contentLock before NotifyChanged, so Dispose() can run
in the gap, complete _invalidated.OnCompleted()/Dispose() (which are called
outside the lock), and the racing mutator's OnNext then throws
ObjectDisposedException from R3.Subject<T>.OnNext on a disposed Subject.
Same shape applies to a deliberate use-after-dispose call.

Fix:
- NotifyChanged() reads the volatile _disposed flag and bails before touching
  _invalidated. A try/catch (ObjectDisposedException) handles the narrow
  window where the flag reads false but Dispose() completes between the read
  and OnNext — harmless because a disposed node has no live observers.
- Route OnAnimationInvalidated's notification through NotifyChanged instead
  of inlining _invalidated.OnNext, so the animation path inherits the same
  hardening and the cross-cutting NotifyChanged point isn't bypassed (any
  future instrumentation hook there now covers animation frames too).

Tests:
- 12 parameterized cases covering every public mutator after Dispose().
  Verified the suite FAILS without the guard (11 of 12 cases throw
  ObjectDisposedException; the 2 outliers — Remove/Replace with a missing
  id — return false before reaching NotifyChanged) and PASSES with the
  guard restored.
- Append_ConcurrentWithDispose_DoesNotThrow: stress test where Append fires
  on a background thread while the main thread disposes the node mid-flight,
  bounded to 250ms wall clock.

1138/1138 tests pass.

- Update VersionPrefix to 0.10.1
- Refresh PackageReleaseNotes with the StreamingTextNode thread-safety
  fixes (PRs #224, #225, #226, #227)
- Prepend 0.10.1 section to RELEASE_NOTES.md