Instruction set doesn’t really matter
You’re absolutely right. Intel hasn’t run x86 or x64 natively for years. Instead, they have an internal instruction set decoder/recompiler implemented mostly as ASIC and partially as microcode to make it so x86 and x64 is little more that a means of delivering a program. In fact, it’s similar to .NET CIL or Java IL. It’s actually much closer to LLVM IL.
There are some real benefits to this, first is that the recompiler can identify instructions that can be executed out of order as there are no register or cache read/write dependencies. Alternatively, it can automatically run instructions on parallel on separate parts of one or more ALUs which lack dependencies. As such, more advanced cores can process the same code in less clock cycles assuming there is no contentions.
Microsoft has spent 15 years moving most non-performance critical code away from x86 or anything else and over to .NET. They also have implemented the concept of fat-binaries like Apple did with PPC, ARM and x86/x64. In addition, they have been making LLVM and CLang part of Visual Studio. Windows probably has a dozen technologies that allow platform agnostic code to run on Windows now.
Emulating x86 is nice, but is really only necessary for older and unmaintained software. Most modern programs can carry across platforms with little more than a recompile and for power conscious devices GPU intensive code will be the same and CPU intensive code is frowned upon. So, you wouldn’t want to run x264 for example on a low power device ... and certainly not emulated. You’d favor either a video encoder core or a GPU encoder.
As for JIT and AOT dynamic recompilers, I can literally write a book on the topic, but there is absolutely no reason why two architectures as similar as x86 and ARM shouldn’t be able to run each other’s code at near native speed. In fact, it may be possible to make the code run faster if targeting the specific local platform. Also consider that we have run ARM binaries emulated on x86 for a long time, the performance is very respectable. I believe Microsoft is more focused on accuracy and limitation of patent infringement. Once they get it working, it is entirely possible that running x86 on x86 may be faster than running native because JITs are amazing technology in that they can do things like intelligently pipeline execution branches and realign execution order for the host processor.
Nice comment though :)