fix(serializer): preserve deserialization path and expected type on IRI type-confusion guard

The type-confusion guard in AbstractItemNormalizer::getResourceFromIri()
threw a bare NotNormalizableValueException, dropping the deserialization
path and expected type. With COLLECT_DENORMALIZATION_ERRORS enabled,
DeserializeProvider::createViolationFromException() then produced an empty
"This value should be of type ." violation with no property path
(regression from #8333 vs 4.3.13).

Build the exception through createForUnexpectedDataType() so the path and
expected type are preserved, while keeping it a NotNormalizableValueException
so union/intersection denormalization still falls through to the next member.

Closes #8352

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: alexndlm

src/Serializer/AbstractItemNormalizer.php

@@ -773,7 +773,7 @@ private function getResourceFromIri(string $data, array $context, string $resour
                 : is_a($item, $resourceClass);
 
             if (!$matchesType) {
-                throw new NotNormalizableValueException(\sprintf('The iri "%s" does not reference the correct resource.', $data));
+                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Invalid IRI "%s".', $data), $data, [$resourceClass], $context['deserialization_path'] ?? null, true);
             }
 
             return $item;

src/Serializer/Tests/AbstractItemNormalizerTest.php

@@ -1329,6 +1329,41 @@ public function testUnionTypeCollectionDenormalizationAcceptsAnyMember(): void
         $this->assertInstanceOf(Dummy::class, $actual);
     }
 
+    public function testTypeConfusionGuardPreservesPathAndExpectedType(): void
+    {
+        $propertyNameCollectionFactoryProphecy = $this->prophesize(PropertyNameCollectionFactoryInterface::class);
+
+        $propertyMetadataFactoryProphecy = $this->prophesize(PropertyMetadataFactoryInterface::class);
+
+        // The IRI resolves to a Dummy while a RelatedDummy is expected: the type-confusion guard must reject it.
+        $iriConverterProphecy = $this->prophesize(IriConverterInterface::class);
+        $iriConverterProphecy->getResourceFromIri(Argument::cetera())->willReturn(new Dummy());
+
+        $resourceClassResolverProphecy = $this->prophesize(ResourceClassResolverInterface::class);
+        $resourceClassResolverProphecy->getResourceClass(null, RelatedDummy::class)->willReturn(RelatedDummy::class);
+        $resourceClassResolverProphecy->isResourceClass(RelatedDummy::class)->willReturn(true);
+
+        $propertyAccessorProphecy = $this->prophesize(PropertyAccessorInterface::class);
+
+        $serializerProphecy = $this->prophesize(SerializerInterface::class);
+        $serializerProphecy->willImplement(DenormalizerInterface::class);
+
+        $normalizer = new class($propertyNameCollectionFactoryProphecy->reveal(), $propertyMetadataFactoryProphecy->reveal(), $iriConverterProphecy->reveal(), $resourceClassResolverProphecy->reveal(), $propertyAccessorProphecy->reveal(), null, null, [], null, null) extends AbstractItemNormalizer {};
+        $normalizer->setSerializer($serializerProphecy->reveal());
+
+        try {
+            $normalizer->denormalize('/dummies/1', RelatedDummy::class, null, [
+                'not_normalizable_value_exceptions' => [],
+                'deserialization_path' => 'relatedDummy',
+            ]);
+            $this->fail('Expected a NotNormalizableValueException to be thrown.');
+        } catch (NotNormalizableValueException $exception) {
+            $this->assertSame('Invalid IRI "/dummies/1".', $exception->getMessage());
+            $this->assertSame('relatedDummy', $exception->getPath());
+            $this->assertSame([RelatedDummy::class], $exception->getExpectedTypes());
+        }
+    }
+
     public function testDenormalizeRelationNotFoundReturnsNull(): void
     {
         $data = [