Add haxe.runtime.Copy

[Simn]

From #11857.

Needs more tests and such.

Closes #11862.

[ALANVF]

I'm excited for this new addition, although I noticed that copyValue is Dynamic. Is there a reason why it could not be made generic instead as copyValue<T>(value: T): T? It works the same way while still preserving type safety

[Simn]

The reason is mostly that I copied this from Nicolas. And yes we should definitely change it to copyValue<T>(value: T): T here.

[Simn]

There are two situations related to __id__ handling on JS/neko:

1. The Serializer and the original implementation do some nasty looking Reflect.deleteField(k, "__id__") stuff when handling ObjectMap keys. After looking at this a bit I don't see why this is necessary because the implementation of Reflect.fields on both JS and neko already deals with __id__ fields, so they will not be serialized/copied.

2. With the cache being an ObjectMap now, we end up adding __id__ fields to keys:

function main() {
	var obj1 = {};
	var obj1Copy = haxe.Copy.copy(obj1);
	trace(obj1); // { __id__: 0 }
	trace(obj1Copy); // {}
}

We could look into removing these values after copying, but I don't know if that would actually improve anything. Ultimately this happens for any implementation that uses ObjectMap, so maybe it's acceptable to leave this as-is.

Edit: I've changed it to not use ObjectMap on neko and JS, so there is no __id__ business now.

[Simn]

I took another look at the enum parameter handling of the original implementation and decided to forego it. It was implemented for neko, php and js and as it turns out, it actually wasn't working on JS unless -D js-enums-as-arrays was set. And I don't think we need an implementation that works only on neko and php.

This means that the copy implementation will also run into what I outlined in #11865. This isn't ideal, but it's also not fatal because enum values cannot be recursive by themselves, and so at worst they end up appearing as multiple instances.

Edit: This is now addressed by deferring all recursions. This ensures the enum value instance is cached before anyone else can come across it again.

[Simn]

This should be fine now. I'm sure it can be optimized more but it's a good start.

The remaining question is where to actually put this. Having haxe.Copy is a bit random, but I don't want to add it to some other class and I don't know if it makes sense to open a new haxe.runtime package or whatever.

[Simn]

I've created the haxe.runtime package after all, this might be a good place to put various lowish-level target runtime support code.