Regarding the versioning scheme:
Using the moduleinfo flags would actually make the druntime implementation more complicated, not simpler. At least if it offered the same features:

This pull changes the 'all tests in a module as one function' idea into 'One array of unittests for every module'. How a unittest looks like does not matter at first, we just have an array of 'version+pointer'.

With this approach we can easily pair libraries compiled with a newer compiler with an older druntime or the other way round. It's a first step to ABI stability and it slightly complicates the code, but I think that's justified as it avoids breaking ABI and / or code later on.
(Let's say we use moduleinfo bits for versioning. Now we want to add one additional field for all unittests. We set a new bit in moduleinfo, ok. But what should ```unitTests``` in druntime return? The return type can't change (different struct size-> ABI breakage). So we add yet another unitTests2 property to druntime. But then old test runners stop working. With this abstraction "pointer+version" we can easily upgrade the format without breaking anything)

Now this abstraction could still be used without explicitly storing the version and instead getting version information from moduleinfo flags. But then the version has to be passed from the moduleinfo to ```__UnitTest``` in some way, which means that ```unitTests``` can no longer return a simple array, it has to return a range. As unittests are only compiled in if they're explicitly enabled, the executable size overhead of one extra word per unittest shouldn't matter.