Massive script+with+self set of fixes, +1 optimization

Greetings. This pull request fixes 3 intricately connected errors, and includes 1 related optimization. Unfortunately, it is somewhat complex.

=================
Fix 1
=================
If object1 and object2 have the following event code, and scr_1 is "localized" into the objects, then object1 will accidentally call object2's localized script. (This issue was reported before, but at the time my fix was not stable.) 
```
//object1:
with(object2) {
  scr_1();
}

//object2:
if (/*something*/) { scr_1(); }
```

The solution is to replace "scr_1();" with "::scr_1()" in all such cases. Note that my solution allows (in the future) for "scr_1()" to be replaced with something like "((object_1)(self))->scr_1();", which is ultimately more efficient (1 dynamic cast versus a lookup on every single variable access in the script). That optimization is far into the future, however.

=================
Fix 2
=================
If you access "other" in an event when it is not clearly defined (e.g., "create"), then it is supposed to be set to "self" (GM5 and GM:S do this). Instead, ENIGMA sets it to "random garbage". I've fixed this.

=================
Fix 3
=================
Most global scripts in ENIGMA start with the following line:
```
with((self)) {
  /*script code*/
}
```
This is added so that variables inside of scripts are wrapped with a "varaccess(self)" tag, so it is necessary at compile time. At runtime, however, it leads to an incorrect "other" state. Consider the following:
```
//object1, event, pseudo-code:
//assume other != self
show_message(self + " : " + other);
::scr_1();

//scr_1, pseudo-code:
with((self)) {  //Uh-oh, now other == self!
  show_message(self + " : " + other);  
}
```

The correct behavior (used by GM5 and GM:S) is to preserve the values of other and self, even across script boundaries. I fixed this by removing the "with((self))" wrapper after parsing, directly before the script is written to a file.

=================
Optimization 1
=================
As a kind of sweetener, I implemented a simple optimization: whenever script_execute(X,...) is called, if the "X" is a well-known script name, simply call X directly. Although this is marginally faster than a function pointer de-reference, the real gain is that it allows X() to now call the object-localized version in many cases! The only time this will not work is if you are calling script_execute() with a script ID directly.

=================
Final Thoughts
=================
As always, let me know if you have any questions. It goes without saying that all of these fixes are related to real, observed problems in Iji, not just obscure hypothesizing.