Reduce duplicate custom scalars tests between core APIs and React hooks (#13368)

When I first started working on custom scalars, I added tests all over
the place to ensure it works throughout the entirety of the library. The
problem however is that I essentially duplicated the entire test suite
across every React hook. Since all React hooks use `client.watchQuery`
under the hood, `client.watchQuery` tests really should be the test
suite that checks all the edge cases (fetch policies, defer/stream,
etc.), otherwise future maintenance is going to be a nightmare if we
have to duplicate new tests for every React hooks.

The React hook custom scalars test suites are now reduced to a more
minimal set to ensure the integration works as expected, but the core
APIs are now where the full suite lives. This will make it easier to add
tests in the future without having to duplicate them everywhere.

<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->

## Summary by CodeRabbit

* **Tests**
* Expanded coverage for custom scalar parsing, including `Date` values
returned through deferred and incremental responses.
* Updated query, mutation, subscription, suspense, and preloader
scenarios to validate parsed scalar fields and variables.
* Added checks that identical scalar results preserve stable data
references and avoid unnecessary updates.
* Refined error-policy and loading-state expectations for successful
parsed results.

<!-- end of auto-generated comment: release notes by coderabbit.ai -->

Author: jerelmiller

src/core/__tests__/client.mutate/customScalars.test.ts

@@ -9,8 +9,17 @@ import {
   NetworkStatus,
 } from "@apollo/client";
 import { InMemoryCache } from "@apollo/client/cache";
+import {
+  Defer20220824Handler,
+  GraphQL17Alpha9Handler,
+} from "@apollo/client/incremental";
 import { MockLink } from "@apollo/client/testing";
-import { dateScalar, ObservableStream } from "@apollo/client/testing/internal";
+import {
+  dateScalar,
+  mockDefer20220824,
+  mockDeferStreamGraphQL17Alpha9,
+  ObservableStream,
+} from "@apollo/client/testing/internal";
 
 test("serializes scalar variables used in field arguments", async () => {
   let requestVariables!: OperationVariables;
@@ -857,3 +866,123 @@ test("parses custom scalar fields with an `ignore` error policy", async () => {
     },
   });
 });
+
+test("parses custom scalar fields across `@defer` payloads (defer20220824)", async () => {
+  const link = mockDefer20220824();
+  const client = new ApolloClient({
+    cache: new InMemoryCache({
+      scalars: { Date: dateScalar },
+      typePolicies: {
+        Event: {
+          fields: {
+            startDate: { scalar: "Date" },
+            endDate: { scalar: "Date" },
+          },
+        },
+      },
+    }),
+    link: link.httpLink,
+    incrementalHandler: new Defer20220824Handler(),
+  });
+  const mutation = gql`
+    mutation CreateEvent {
+      createEvent {
+        id
+        startDate
+        ... @defer {
+          endDate
+        }
+      }
+    }
+  `;
+
+  const promise = client.mutate({ mutation });
+
+  link.enqueueInitialChunk({
+    data: {
+      createEvent: {
+        __typename: "Event",
+        id: "1",
+        startDate: "2026-01-01",
+      },
+    },
+    hasNext: true,
+  });
+
+  link.enqueueSubsequentChunk({
+    incremental: [{ data: { endDate: "2026-02-02" }, path: ["createEvent"] }],
+    hasNext: false,
+  });
+
+  await expect(promise).resolves.toStrictEqualTyped({
+    data: {
+      createEvent: {
+        __typename: "Event",
+        id: "1",
+        startDate: new Date(2026, 0, 1),
+        endDate: new Date(2026, 1, 2),
+      },
+    },
+  });
+});
+
+test("parses custom scalar fields across `@defer` payloads (graphql17Alpha9)", async () => {
+  const link = mockDeferStreamGraphQL17Alpha9();
+  const client = new ApolloClient({
+    cache: new InMemoryCache({
+      scalars: { Date: dateScalar },
+      typePolicies: {
+        Event: {
+          fields: {
+            startDate: { scalar: "Date" },
+            endDate: { scalar: "Date" },
+          },
+        },
+      },
+    }),
+    link: link.httpLink,
+    incrementalHandler: new GraphQL17Alpha9Handler(),
+  });
+  const mutation = gql`
+    mutation CreateEvent {
+      createEvent {
+        id
+        startDate
+        ... @defer {
+          endDate
+        }
+      }
+    }
+  `;
+
+  const promise = client.mutate({ mutation });
+
+  link.enqueueInitialChunk({
+    data: {
+      createEvent: {
+        __typename: "Event",
+        id: "1",
+        startDate: "2026-01-01",
+      },
+    },
+    pending: [{ id: "0", path: ["createEvent"] }],
+    hasNext: true,
+  });
+
+  link.enqueueSubsequentChunk({
+    incremental: [{ data: { endDate: "2026-02-02" }, id: "0" }],
+    completed: [{ id: "0" }],
+    hasNext: false,
+  });
+
+  await expect(promise).resolves.toStrictEqualTyped({
+    data: {
+      createEvent: {
+        __typename: "Event",
+        id: "1",
+        startDate: new Date(2026, 0, 1),
+        endDate: new Date(2026, 1, 2),
+      },
+    },
+  });
+});