There was a bug with the enum placeholder ordering

Input like the following
```
            interface SomeInterface  {
                product_type: String @doc(description: "The type of product, such as simple, configurable, etc.")
            }
            enum SomeEnum {
            }
```

would have placeholder logic ran against it and end up like
```
            interface SomeInterface  {
                product_type: String @doc(description: "The type of product, such as simple, configurable, etc.")
            }
            enum SomeEnum {
placeholder_graphql_field: String
}
```

This caused an error, something in the AST was trying to make it resolve against the word "Type" in the @doc description

By fixing the enum so that it does not have `: String` in it the AST is generated successfully, we do this by replacing those empty enums first so that they cannot get caught by the empty type check

The newly supported union is the cause of this issue in the parseTypes function.

The regex is finding the type of union CompanyStructureEntity but its also grabbing the item below it and including it as part of its schema content, which means CompanyStructureEntity contains the schema for itself as well as CompanyStructureItem , this means I never have a $knownTypes['CompanyStructureItem']  to work with which means it is a missing dependency.

```
<?php
use Magento\Framework\App\Bootstrap;
require __DIR__ . '/app/bootstrap.php';
​
$bootstrap = Bootstrap::create(BP, $_SERVER);
$obj = $bootstrap->getObjectManager();
/** @var Magento\Framework\GraphQlSchemaStitching\GraphQlReader $graphqlReader */
$graphqlReader = $obj->get(Magento\Framework\GraphQlSchemaStitching\GraphQlReader::class);
$reflector = new ReflectionObject($graphqlReader);
$method = $reflector->getMethod('parseTypes');
$method->setAccessible(true);
​
$broken =
'type IsCompanyEmailAvailableOutput @doc(description: "Contains the response of a company email validation query") {
    is_email_available: Boolean! @doc(description: "A value of `true` indicates the email address can be used to create a company")
}
​
union CompanyStructureEntity @typeResolver(class: "Magento\\CompanyGraphQl\\Model\\Resolver\\StructureEntityTypeResolver") = CompanyTeam | Customer
​
type CompanyStructureItem @doc(description: "Defines an individual node in the company structure") {
    id: ID! @doc(description: "The unique ID for a `CompanyStructureItem` object")
    parent_id: ID @doc(description: "The ID of the parent item in the company hierarchy")
    entity: CompanyStructureEntity @doc(description: "A union of `CompanyTeam` and `Customer` objects")
}
​
type CompanyStructure @doc(description: "Contains an array of the individual nodes that comprise the company structure") {
    items: [CompanyStructureItem] @doc(description: "An array of elements in a company structure")
}';
​
$result = $method->invoke($graphqlReader, $broken);
​
echo "Got the following types" . PHP_EOL;
echo implode(PHP_EOL, array_keys($result)) . PHP_EOL;
​
echo "The values for the union actually contains CompanyStructureItem which is why the initial approach works any mine does not" . PHP_EOL;
echo $result['CompanyStructureEntity'] . PHP_EOL;
```

Based on feedback from magento#31879 (comment) @Bartlomiejsz

> regarding first issue - with empty enum. It looks like the fix is to replace first matching group in both $typeDefinitionPattern variables:
>
> ([^\{]*)
> with:
> 
> ([^\{\}]*)
> Then this regex will check if there is neither beginning or ending bracket in this place

This reverts commit 53c5cf8.

This reverts commit 7223e89.

…hql-stitching-perf

…hql-stitching-perf

Based on feedback magento#31879 (comment) from @Bartlomiejsz

> regarding first issue - with empty enum. It looks like the fix is to replace first matching group in both $typeDefinitionPattern variables:
>
> ([^\{]*)
> with:
>
> ([^\{\}]*)
> Then this regex will check if there is neither beginning or ending bracket in this place

…hql-stitching-perf

 Conflicts:
	lib/internal/Magento/Framework/GraphQlSchemaStitching/GraphQlReader.php

This workaround handles a bug where parseTypes also contains the data from below it

```
union X = Y | Z

type foo {}
```

Would return
```php
[
    'x' => 'union X = Y | Z

    type foo {}'
]
```

instead of
```php
[
    'x' => 'union X = Y | Z',
    'foo' => 'type foo {}'
]
```

This workaround deals only with union types, so doesnt materially affect anything in most cases.