Optimize CowData and LocalVector functions .insert and .remove_at by using move semantics.

[Ivorforce]

This PR uses move semantics to move regions in CowData, avoiding repeated copy assignments and destructions.

Safer, but still very fast, version of #100468. #100468 may still be re-opened if needed at some point, but it turns out most of the performance loss from these functions can already be avoided with this simple change.

Beneficiaries of this change include Array, PackedStringArray, and other internal Vector types that use non-trivial elements.

Additionally, some minor inefficiencies are addressed in Vector and LocalVector implementations.

Benchmark

I benchmarked the following code:

	int N = 10000;
	int M = 1000;
	Array vectors[N];
	for (int i = 0; i < N; i++) {
		for (int j = 0; j < M; ++j) {
			vectors[i].push_back("Test");
		}
	}

	{
		auto t0 = std::chrono::high_resolution_clock::now();
		for (int i = 0; i < N; i ++) {
			vectors[i].remove_at(0);
		}
		auto t1 = std::chrono::high_resolution_clock::now();
		std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count() << "ms\n";
	}

	{
		auto t0 = std::chrono::high_resolution_clock::now();
		for (int i = 0; i < N; i ++) {
			vectors[i].insert(0, vectors[0][0]);
		}
		auto t1 = std::chrono::high_resolution_clock::now();
		std::cout << std::chrono::duration_cast<std::chrono::milliseconds>(t1 - t0).count() << "ms\n";
	}

This yields:

• 121ms and 110ms on Add move assignment and move constructor to Variant. #100426 (34fa0bf)
• 22ms and 13ms on a combined merge of this PR and Add move assignment and move constructor to Variant. #100426

As such, it can be concluded that remove_at can be 5.5x as fast as before, and insert can be 8x as fast.

Addendum

Arguably, push_back and pop_back() should be added to CowData, because quite a few callers have various ways of implementing these operations themselves. They could be accelerated with move semantics quite easily, and an efficient implementation would be considerably faster than insert and remove_at.

[hpvb]

I am happy with this. This will safely use move constructor and assignment overloads where available, and fall back to the normal T& and const T assignment overloads otherwise.

As we add more move constructors and assignment operators to core types this will eventually be as fast as the original version, but without causing any uncertainty about safety in the meantime.

This is at worst a no-op, but since we already have move constructors on some of our more expensive types it won't be!

[AThousandShips]

LGTM

[hpvb]

I did some benchmarks using https://github.com/godotengine/godot-benchmarks between master and this pr + #100483 and after running both master and that combination several times I can confirm that emitting signals is roughly ~10% faster with these changes compared to master, I also think that I see an improvement in the ObjectDB benchmarks but with 64 threads on my computer there's a ton of noise in the threads and it is hard to be sure.

Function Callable seems to be 1% slower though, even after repeated runs. I can't explain it.

[Repiteo]

Thanks!