fix(forms/signals): propagate pending state through grandchild fields

The `pending()` signal only checked direct children's `asyncErrors` for
pending sentinels, so a grandchild's async validator would not bubble the
pending state up to the grandparent. This caused `InteropNgControl.status`
to throw an AssertionError when the field tree had three or more levels and
an async validator was placed on a grandchild field (status was 'unknown'
but `pending()` returned false).

- Fix `FieldValidationState.pending` to recursively call
  `child.validationState.pending()` instead of checking
  `child.validationState.asyncErrors().includes('pending')`.
- Replace the unreachable `throw` in `InteropNgControl.status` with a
  defensive `return 'PENDING'` fallback that correctly maps the 'unknown'
  validation status to Angular's FormControlStatus.
- Add a regression test for the grandchild pending propagation scenario.

https://claude.ai/code/session_01VdGf6HYafkbRfpEBJYL9Te

Author: claude

packages/forms/signals/src/controls/interop_ng_control.ts

@@ -114,16 +114,13 @@ export class InteropNgControl
     if (this.field().disabled()) {
       return 'DISABLED';
     }
-    if (this.field().valid()) {
-      return 'VALID';
-    }
     if (this.field().invalid()) {
       return 'INVALID';
     }
-    if (this.field().pending()) {
-      return 'PENDING';
+    if (this.field().valid()) {
+      return 'VALID';
     }
-    throw Error('AssertionError: unknown form control status');
+    return 'PENDING';
   }
 
   valueAccessor: ControlValueAccessor | null = null;

packages/forms/signals/src/field/validation.ts

@@ -262,7 +262,7 @@ export class FieldValidationState implements ValidationState {
     reduceChildren(
       this.node,
       this.asyncErrors().includes('pending'),
-      (child, value) => value || child.validationState.asyncErrors().includes('pending'),
+      (child, value) => value || child.validationState.pending(),
     ),
   );
 

packages/forms/signals/test/node/validation_status.spec.ts

@@ -416,6 +416,40 @@ describe('validation status', () => {
       expect(f().valid()).toBe(false);
       expect(f().invalid()).toBe(true);
     });
+
+    it('grandparent should be pending while grandchild async validator is pending', async () => {
+      let res: Resource<unknown>;
+
+      const f = form(
+        signal({child: {grandchild: 'VALID'}}),
+        (p) => {
+          validateAsync(p.child.grandchild, {
+            params: ({value}) => value(),
+            factory: (params) =>
+              (res = resource({
+                params,
+                loader: ({params}) =>
+                  new Promise<ValidationError[]>((r) =>
+                    setTimeout(() => r(validateValueForChild(params, undefined))),
+                  ),
+              })),
+            onSuccess: (results) => results,
+            onError: () => null,
+          });
+        },
+        {injector},
+      );
+
+      expect(f().pending()).toBe(true);
+      expect(f().valid()).toBe(false);
+      expect(f().invalid()).toBe(false);
+
+      await appRef.whenStable();
+
+      expect(f().pending()).toBe(false);
+      expect(f().valid()).toBe(true);
+      expect(f().invalid()).toBe(false);
+    });
   });
 
   describe('multiple validators', () => {