Add GDScriptType wrapper instead of GDScriptNativeClass

[dalexeev]

There is a GDScriptNativeClass wrapper available in GDScript, you can obtain it as a first class value (var node_class = Node), although it is not exposed, which creates some problems.

At the same time, there is no such wrapper for built-in types (like GDScriptBuiltInType). In particular, this has resulted in the is_instance_of() function uses TYPE_* constants to denote a built-in type, and is_instance_of() does not support typed arrays.

I think we should fix this. For example, we can add a GDScriptType class (exposed in ClassDB) with API like this:

class GDScriptType extends RefCounted

static func from_builtin_type(builtin_type: Variant.Type) -> GDScriptType
static func from_native_type(native_type: StringName) -> GDScriptType
static func from_script_type(script_type: Script) -> GDScriptType
static func from_instance(instance: Variant) -> GDScriptType

func get_builtin_type() -> Variant.Type
func get_native_type() -> StringName
func get_script_type() -> Script

func is_typed_container_type() -> bool
func get_typed_container_type() -> GDScriptType

func can_instantiate() -> bool
func instantiate(args: Array = []) -> Variant

# TODO: enum API

GDScriptType instances represent a type in GDScript. You can use the name of a built-in type, native type, or GDScript type like in type hints to get GDScriptType instance:

var builtin_type = String
var typed_array = Array[String]
var native_type = Node
var native_enum = Side
var gdscript_class = MyClass
var gdscript_enum = MyEnum

GDScriptType is similar to GDScriptParser::DataType, but can represent not only a static type, but also a runtime type. Probably GDScriptType should be treated as a constant, you can't change it or create it dynamically (GDScriptType.new()). GDScriptNativeClass will no longer be needed.

This will probably require quite a lot of changes and will break backwards compatibility a bit (for those who rely on something like str(value).begins_with("<GDScriptNativeClass#")), but I think that this will help us avoid many problems in the future and solve some of the existing ones.

Another question we have to solve is how to distinguish the methods of the instance representing the type from the static methods of the type.

[vonagam]

There is a need for a proper entity to represent a type. But I think it should be done at the core level, not gdscript one. Because such representation will be really useful in implementing type parameters for other built-in types. And for arrays it will make it possible to have nested parameter types - Array[Array[int]].