fix(forms): flush debounced descendant values when a field is touched - #71150

AGENT: Great catch on syncing pending values when a field is touched!

However, there is an inconsistency introduced by putting child.flushSync() directly in the descendant loop. If a child control skips validation (for example, if it's hidden or disabled), child.markAsTouchedInternal() will return early and will not iterate over its own descendants. Because of the unconditional child.flushSync() in the parent's loop, this results in:

1. The hidden/disabled direct child is flushed.
2. The grandchildren of that hidden/disabled child are not flushed.

To fix this inconsistency and fulfill the goal of flushing exactly when a node is marked as touched, we can move this.flushSync() directly into markAsTouchedInternal() right after marking the state, and remove the manual flush from the markAsTouched wrapper.

Here is what that would look like:

  markAsTouched(options?: MarkAsTouchedOptions): void {
    if (this.structure.isOrphaned()) {
      return;
    }
    untracked(() => {
      this.markAsTouchedInternal(options);
      // Removed this.flushSync() here
    });
  }

  markAsTouchedInternal(options?: MarkAsTouchedOptions): void {
    if (this.structure.isOrphaned()) {
      return;
    }
    if (this.validationState.shouldSkipValidation()) {
      return; // Hidden/Disabled fields correctly bail out BEFORE flushing
    }
    this.nodeState.markAsTouched();
    this.flushSync(); // Flush happens EXACTLY when marked as touched
    
    if (options?.skipDescendants) {
      return;
    }
    for (const child of this.structure.children()) {
      child.markAsTouchedInternal();
      // Removed child.flushSync() here
    }
  }

This ensures that hidden/disabled fields (and their descendants) correctly bail out before flushing, keeping the tree consistent.

AGENT: Thanks for tackling #71149! Ensuring that debounced descendant inputs flush their pending values before submission actions execute makes total sense and fixes the issue when submitting via Enter while inputs remain focused.

A few items to consider for this PR:

1. Lazy Materialization of Skipped Branches: Removing the early return on shouldSkipValidation() forces eager traversal (this.structure.children()) of all disabled, hidden, or readonly subtrees during markAsTouched(), which eagerly materializes inactive fields that were meant to remain lazy.
2. Reactivity & State Ordering: Invoking flushSync() before markAsTouched() updates value while touched is still false, briefly exposing an intermediate state to reactive consumers.
3. Edge Case Test Coverage: Adding tests for invalid debounced values on submit (verifying the action is prevented and errors surfaced), duration-based debounces, and multiple sibling fields.
4. Squash Commits: Please squash the fixup! commit prior to merge.

I've left inline comments with additional details!

AGENT: Thanks for updating this @MeAkib! Left a design note inline regarding the trade-off of flushing inactive (shouldSkipValidation()) fields versus the pre-#67453 early return behavior.