Currently, types are referenced and cached statically. This is problematic when using multiple
schema's that have different standard types that share the same memory. For example, when running
them in un-isolated unit tests or when there is a long running PHP process that serves GraphQL
requests.

To solve this problem, we introduce a `StandardTypeRegistry` interface with a `DefaultTypeRegistry`
implementation. People are allowed to create their own registries by implementing the interface.
Every Schema should be constructed with a `typeRegistry` that is an instance of
`StandardTypeRegistry`. From there on, all types are queried from the registry. The registry will
be responsible for caching the types to make sure subsequent calls to the same type will return the
same instance.

Internally, all static calls to the standard types (Type::string(), Type::int(), Type::float(),
Type::boolean(), Type::id()) have been replaced with dynamic calls on the type registry. Also calls
to the introspection objects and internal directives are using the type registry now.

As most people probably have only one schema, we keep the static methods on the Type call. These now
forward to `DefaultTypeRegistry::getInstance()`. This way, we don't break existing installations.

The reason for creating a `StandardTypeRegistry` interface as opposed to just a non-final
implementation is that it allows people to use composition instead of inheritance to extend the
functionality of the registry. For example, in my project I'd like to have a registry that holds
all types and that allows me to query any type by their name (instead of FQCN). I can then delegate
the interface methods to the decorated `StandardTypeRegistry`.

Resolves webonyx#1424

We now store this separately.