> Yeah I think Unity just doesn't have the technical skillset anymore
It's not a technical skillset issue, it's a case of lacking resources, leadership changing priorities and changing requirements mid-development, causing a lot of work to be redone.
We still have highly skilled developers working in this area, if we can just actually be allowed to do (and keep) we work we have.
To answer that there are two main factors:
1) For this kind of single instance gene transfer to have an evolutionary effect, it will need to happens to germ-line cell (so an egg or sperm cell in a multi-cellular organism, or in a single-celled organism). Otherwise the mutation won't be inheritable and it won't be evolution, just mutation.
2) The organism(s) affected by this gene transfer would need to be under some evolutionary pressure that would benefit from extra genetic variance. Genetic variance in itself is not a driver of evolution, evolutionary pressure is, which does need the variance to actually do anything. Pressure is the sculptor and variance is the clay, without one of those there won't be a statue.
Also, normally most random mutations are either negative or neutral (there's a lot more ways an organism can be dead than alive), so I would suspect this might also be true of gene transfers. Though gene transfers from environmental DNA isn't as random as direct genetic mutation, so perhaps there's something interesting happening there. But I wouldn't be surprised to find out that the risk of cancer or viral infections would be higher.
The life/dinner principle doesn't work in absolutes, it just states that you would expect asymmetric evolutionary pressures from asymmetric stakes in interactions.
It's also worth taking the "Life/dinner principle"[0] into account. If the termites fail to detect the beetle, then they might loose a tiny bit of food or whatever. While if the beetle fails to deceive the termites it might get killed or starve. Hence the adaptive pressure is probably higher for the beetle than for the termites.
0: The name comes from the example: the rabbit runs faster than the fox, because the rabbit is running for its life, while the fox is running for its dinner.
Well, the question is in reality either unanswerable (we don't know - and may never know - how many and when the first proto-language(s) emerged) or meaningless (all live natural languages go back as far as we can reconstruct or attest to).
Just as a little correction: Dutch is not an "evolved German dialect". German and Dutch are both West Germanic languages, but so is Scots, Frisian and English. So it would be like saying that German is an evolved English dialect then (though to be fair, Dutch and German are grouped closer to each-other in that family tree usually and have provided a lot of substrate for each-other due to close contact).
Swiss German is not regarded as a its own language by any nation, though from a purely linguistic perspective it could very well be classified as its own language. What is deemed a language vs. a dialect usually comes down to politics. The saying usually goes something like: "A language is just a dialect with an army".
It's also okay to have opinions about language of course. I just often see people confidently stating, that they're speak the right way, and those others (from that other city, country, those young people, those poor people, those black people, etc.) speak the wrong way. And it often boils down to either ignorance about how languages actual work and evolve, or just elitism/classism (or worse).
And as somebody who cares a lot about languages, this just rubs me the wrong way, and I see it so often.
Hence my previous response, pardon the snark:)
If you're curious about how their YJIT, with it's lazy basic block versioning, works then I can highly recommend watching their presentation on it: https://www.youtube.com/watch?v=PFb5wNj2ztM
JIT compilation is done lazily on a per basic block level (so you only JIT blocks you're about to run). It keeps track of statically known information for specific basic-blocks and specializes different versions of basic blocks based on this. So if you're coming from an if-statement checking the type of X, into a new basic block, then the JIT specializes the block based on the knowledge that X indeed has said type (so it can specialize operations or skip future checks).