* The expression was already adding its usage indication,
undo that such that next micro pass knows if it's used
or not sooner. Otherwise it may not happen if that will
have no other changes. And if it did, it will need even
one more than necessary.
* We mean for this to be pointing to a "python.exe" near the
code. However, the updating code was inactive. And with the
current "multiprocessing" plugin when that module is loaded,
the value changes to this anyway.
* As a result this went undetected, but it's an important change
to make sure "sys.executable" calls as a binary do not go
unnoticed.
* For 3.13 and earlier the warning was not given, but now with 3.14
it is, but it's actually a type mismatch for all versions.
* It could also be MSVC 14.5 having changed but, but I doubt that
is the case. It's a good change anyway, although obviously it
is not nearly a fix of anything.
* The Python side of things is delayed, but this
is already good, and will stop us from using
the original "annotate" of uncompiled functions
accidentally.
* Re-use start trace objects from previous micro passes,
allocating all over is wasteful and harms cache locality,
this gives a minor performance boost to avoid that.
* Specialize start traces to not have and use a "previous"
trace, making some methods faster since they don't have
to check, and start traces use up less memory as a result
as well.
* Avoid parent class "__init__" calls in value traces, instead
duplicate implementations. That's ugly but only faster.
* For some methods they now can be static methods with start
traces, making their calls slightly faster, too.
* Use proper abstract methods instead of assertions against
being called, that was old code.
* Also shifted the responsibility for setting it to active
to the function that sets it active.
* This improves performance even further since module
variables in modules benefit from the fast code paths
for not escaping them more often.
* Loop optimization was seeing this and then saw the
change to uninit trace only one iteration later
than possible. This could potentially cause a need
for more micro passes than necessary.
* This doesn't do indentation anymore unless asked by
new option or in debug mode, saving 10% of the time
use for generation of code in a larger module.
* Temporary and locals dict variables cannot escape yet were
using a lot of time in virtual method calls.
* This avoids that time entirely making this step even faster.
* We do not take the effort to dynamically clean it up, so
variables could be added there that then don't exist, but
it's still faster this way as those are mostly rare cases.
* This mostly affects module variables which once they
become unknown may frequently escape again.
* The number based check avoids the work for many cases.
* For the very trusted trace check we need to make that
fast to test as well for best results.
