Add Type::makeAllArrayKeysOptional() for preg_replace* array fast path

`ReplaceFunctionsDynamicReturnTypeExtension` previously rebuilt
`ConstantArrayType`s by hand (via `ConstantArrayTypeBuilder`) to map
each value through `getReplaceType()` while optionally marking every
key optional. Replace that with polymorphic dispatch:

  $mapped = $arrayArgumentType->mapValueType(...);
  if ($keyShouldBeOptional) {
      $mapped = $mapped->makeAllArrayKeysOptional();
  }

This collapses the `getConstantArrays()` fast path with the generic
`ArrayType` fallback, keeps non-emptiness/list-ness via the existing
accessory dispatch, and removes the need for the extension to know
about `ConstantArrayTypeBuilder`.

`makeAllArrayKeysOptional()` is implemented across the standard set of
`Type` callees: it marks every explicit key in a `ConstantArrayType`
optional, is a no-op for `ArrayType` (already arbitrary subsets) and
all accessories that do not track per-key optionality, drops
`HasOffsetType`/`HasOffsetValueType` (their guarantee no longer
holds), and distributes through unions/intersections.

Author: ondrejmirtes

src/Type/Accessory/AccessoryArrayListType.php

@@ -280,6 +280,12 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		// Marking keys optional in an arbitrary list keeps it a list.
+		return $this;
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		// List keys are integers; case-folding leaves them alone.

src/Type/Accessory/HasOffsetType.php

@@ -245,6 +245,12 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		// "Has offset X" is no longer guaranteed when X is now optional.
+		return new MixedType();
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		// A string offset is itself case-folded; an int offset is unchanged.

src/Type/Accessory/HasOffsetValueType.php

@@ -333,6 +333,11 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		return new MixedType();
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		if (!$this->offsetType instanceof ConstantStringType) {

src/Type/Accessory/NonEmptyArrayType.php

@@ -264,6 +264,13 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		// Without `ConstantArrayType` keys to mark optional, this is a no-op.
+		// Non-emptiness is unrelated to per-key optionality and is preserved.
+		return $this;
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		// Case-folding keys doesn't change the entry count.

src/Type/Accessory/OversizedArrayType.php

@@ -239,6 +239,11 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		return $this;
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		return $this;

src/Type/ArrayType.php

@@ -593,6 +593,12 @@ public function mapKeyType(callable $cb): Type
 		return new ArrayType($cb($this->keyType), $this->getItemType());
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		// `ArrayType` already models arbitrary key subsets.
+		return $this;
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		$newKeyType = TypeTraverser::map($this->keyType, static function (Type $type, callable $traverse) use ($case): Type {

src/Type/Constant/ConstantArrayType.php

@@ -2000,6 +2000,22 @@ public function mapKeyType(callable $cb): Type
 		return $this;
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		$keyCount = count($this->keyTypes);
+		if ($keyCount === 0) {
+			return $this;
+		}
+
+		return $this->recreate(
+			$this->keyTypes,
+			$this->valueTypes,
+			$this->nextAutoIndexes,
+			range(0, $keyCount - 1),
+			$this->isList,
+		);
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		$builder = ConstantArrayTypeBuilder::createEmpty();

src/Type/IntersectionType.php

@@ -1188,6 +1188,11 @@ public function mapKeyType(callable $cb): Type
 		return $this->intersectTypes(static fn (Type $type): Type => $type->mapKeyType($cb));
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		return $this->intersectTypes(static fn (Type $type): Type => $type->makeAllArrayKeysOptional());
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		return $this->intersectTypes(static fn (Type $type): Type => $type->changeKeyCaseArray($case));

src/Type/MixedType.php

@@ -335,6 +335,12 @@ public function mapKeyType(callable $cb): Type
 		);
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		// `mixed` is already arbitrary; nothing to weaken.
+		return $this;
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		if ($this->isArray()->no()) {

src/Type/NeverType.php

@@ -399,6 +399,11 @@ public function mapKeyType(callable $cb): Type
 		return new NeverType();
 	}
 
+	public function makeAllArrayKeysOptional(): Type
+	{
+		return new NeverType();
+	}
+
 	public function changeKeyCaseArray(?int $case): Type
 	{
 		return new NeverType();