Don't corrupt type registry with false abstract-type tag under deferDeduplicatedFields

RelayResponseNormalizer's TypeDiscriminator and InlineFragment
normalization paths unconditionally write
'client:__type:<ConcreteType>.__is<Interface>: <hasOwnProperty>'
during payload traversal.

Without deferDeduplicatedFields, this is fine: a missing __isFoo tag
in a normalized payload is a real 'type does not implement Foo'
signal, and the false write is load-bearing so DataChecker can skip
future '... on Foo' selections for that concrete type.

Under Environment({ deferDeduplicatedFields: true }), the same missing
tag can just mean 'delivered earlier in a different chunk of this
operation, dedup'd out of the current chunk'. Writing false in that
case is wrong: it plants a schema-contradicting negative claim in the
type registry, and DataChecker (which treats false as authoritative
non-implementation) then silently skips '... on <Interface>' subtrees
for every future query touching that concrete type — never marking
anything missing, never fetching.

Symptom in our app: after an SSR page load that fetches a defer'd
query, client-navigations to any page that reads a Cloudcast via
'node(id) { ... on Node { ... on Cloudcast ... } }' rendered null for
every field inside — reader saw $isWithinUnmatchedTypeRefinement:true
because DataChecker had marked the query 'available' without ever
fetching, thanks to __type:Cloudcast.__isNode=false written during the
defer'd chunk.

Fix: skip the write when 'hasOwnProperty === false && this
._deferDeduplicatedFields'. When the write is skipped, DataChecker
treats the registry entry as unknown (_implementsInterface == null) →
handles missing → fetches on next check → the response arrives with
the tag → true written normally. Non-dedup environments are
byte-identical to the previous behaviour.

Filed as #5389.

Author: jonreading81

packages/relay-runtime/store/RelayResponseNormalizer.js

@@ -283,18 +283,24 @@ class RelayResponseNormalizer {
             data,
             abstractKey,
           );
-          const typeName = RelayModernRecord.getType(record);
-          const typeID = generateTypeID(typeName);
-          let typeRecord = this._recordSource.get(typeID);
-          if (typeRecord == null) {
-            typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
-            this._recordSource.set(typeID, typeRecord);
+          // Under `deferDeduplicatedFields` a missing abstract typename means
+          // the server omitted it as already-delivered, not that the concrete
+          // type fails the type refinement. Skip the write; DataChecker then
+          // treats the entry as unknown and refetches on the next check.
+          if (implementsInterface || !this._deferDeduplicatedFields) {
+            const typeName = RelayModernRecord.getType(record);
+            const typeID = generateTypeID(typeName);
+            let typeRecord = this._recordSource.get(typeID);
+            if (typeRecord == null) {
+              typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+              this._recordSource.set(typeID, typeRecord);
+            }
+            RelayModernRecord.setValue(
+              typeRecord,
+              abstractKey,
+              implementsInterface,
+            );
           }
-          RelayModernRecord.setValue(
-            typeRecord,
-            abstractKey,
-            implementsInterface,
-          );
           break;
         }
         case 'LinkedHandle':
@@ -402,14 +408,21 @@ class RelayResponseNormalizer {
         data,
         abstractKey,
       );
-      const typeName = RelayModernRecord.getType(record);
-      const typeID = generateTypeID(typeName);
-      let typeRecord = this._recordSource.get(typeID);
-      if (typeRecord == null) {
-        typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
-        this._recordSource.set(typeID, typeRecord);
+      // See the `TypeDiscriminator` case above for the reasoning.
+      if (implementsInterface || !this._deferDeduplicatedFields) {
+        const typeName = RelayModernRecord.getType(record);
+        const typeID = generateTypeID(typeName);
+        let typeRecord = this._recordSource.get(typeID);
+        if (typeRecord == null) {
+          typeRecord = RelayModernRecord.create(typeID, TYPE_SCHEMA_TYPE);
+          this._recordSource.set(typeID, typeRecord);
+        }
+        RelayModernRecord.setValue(
+          typeRecord,
+          abstractKey,
+          implementsInterface,
+        );
       }
-      RelayModernRecord.setValue(typeRecord, abstractKey, implementsInterface);
       if (implementsInterface) {
         this._traverseSelections(selection, record, data);
       }