[3.x] Optimize Object::cast_to with ancestral classes when possible

[Ivorforce]

• Follow-up of [3.x] Provide quick access to Object ancestry #107462 (comment)

This implementation should be several times faster than regular Object::cast_to, for classes with corresponding ancestral classes (although i have not tested this).

It would be possible to "pre-check" the types that derive from any of the ancestral types (e.g. object && object.has_ancestry(AncestralClass::SPATIAL) && object.is_class_ptr(SpatialSubclass::get_class_ptr_static())). But that would only accelerate the unhappy path, and only some of the time. The happy path wants to immediately use is_class_ptr, so I decided against this micro optimization.

The _is_class function should use constexpr, but it's not possible until the upgrade to C++17.

4.x equivalent will follow for 4.6, when AncestralClass is forward ported.

[lawnjelly]

I haven't checked the assembly but I did some timings on this PR with the benchmarks from #107462 .

2000 nodes (repeated 1000 times)
release
ancestry 11294, cast 16772

To give some comparison, the results before the PR were (ratio is important here):
ancestry 175, cast 344

So it indicates we are getting a speedup here, but not as much as calling has_ancestry() directly.

I also tried compiling with c++17, and using:

	if constexpr (T::static_ancestral_class != T::super_type::static_ancestral_class) {
		return has_ancestry(T::static_ancestral_class);
	} else {
		return is_class_ptr(T::get_class_ptr_static());
	}

But that didn't appear to help here.

Perhaps this the cost of the branch in cast_to as opposed to _is_class(). 🤔

I.e. in the benchmark we are checking the pointer is non-NULL for cast_to, versus just checking a bool for has_ancestry(). Something like that. We could be measuring something that doesn't matter in practice. Anyway will check further.

UPDATE:
Yes, I can confirm the difference is only due to the NULL pointer check.
If I change the benchmark from:

if (child->has_ancestry(AncestralClass::SPATIAL)) {
	count++;
}

to

if (child && child->has_ancestry(AncestralClass::SPATIAL)) {
	count++;
}

The results are much more similar:
ancestry 15293, cast 16495

This suggests we'll get a general speedup by using cast_to with this PR, but we should still call has_ancestry() directly (or a wrapper function, so ancestry can remain internal) in certain cases (like checking if something is a Reference when we know it isn't NULL).

[lawnjelly]

Just to note also that the big change in whitespace in this PR (which causes confusing diff) is due to switching GDCLASS to use GDSOFTCLASS like in 4.x, and also removing is_class_ptr and self_type from GDCLASS.

The main change is:

• the single static on each class (e.g. static constexpr AncestralClass static_ancestral_class = AncestralClass::REFERENCE;)
• The change to _is_class() to support ancestry.

[lawnjelly]

Thanks!