Replace metadata comments with meta declarations.

This should it make way esier to parse metadata using macros and/or to generate
some of them (like @date) dynamically. Besides, the metadata definition from
haxe really fits well into the userscript syntax with the @ operator.
Add UserScript macro class.

This class currently is only getting metadata from haXe's metadata declarations
and printing it out on compilation. We make use of this later to do a multi-step
compilation by first creating the userscript with the metadata and then
appending the script itself.
Actually generate cncta.user.js.

Now we have implemented our macro class to actually create the cncta.user.js.
Next step will be to fill the unpopulated cncta.user.js with the actual script.
Fill the generated userscript template with data.

This currently just inserts the script "as is", so the whole conditional stuff
is still missing, but it should replace the whole sed/echo stuff and thus should
make it possible to compile it even on Windows.
Add jsmin for minification of JS output.
Factor out macro-only stuff into macro.UserScript.

This will at least get us more clarity of what is macro-only stuff and what can
be called from JS or neko.
Add GetReady which generates the loader template.

This is currently a bit of a hack, but it gets its job done, for a clean
solution there still is the userscript compiler in the works.

It currently just wraps the code inside the generate() method which in turn is
expected to write out the whole loader template plus the code itself.

At the moment, the code is not escaped, so we're generating invalid JS here.
Actually escape generated JS.

This is currently _very_ inefficient, as it is done in-memory and we do several
replacement passes. But for now, even this is okay, is it only increases
compilation time and doesn't cause runtime slow downs.
Implement preliminary watch for webfrontend.

This is not working at the moment, as we really need to inject _twice_. But
do so a few commits later.

It is implemented as a timer using window.setInterval() and every function has
the whole body of the userscript itself. So _THAT_ could definitely become a big
memory hog on the *client-side*.

We might want to avoid that (if possible), but for testing its okay.
Pass compiled code to the template constructor.

The UserScriptTemplate now eats code in its constructor and thus doesn't need to
fiddle everything together in the generate() method.

This also means, that the template class itself is responsible for escaping the
code, which could change in some future version, as we might want to have this
within the UserScript library (among other injection features).
Properly attach to loader and wait for page load.

We have to inject script tags twice, as the internal loader of C&C TA doesn't
trigger a FinishHandler if everything is loaded, it is triggered if the
preloader has finished.
Remove obsolete loader injection stuff from CNCTA.
Remove an empty line at EOF.

I know, this commit is absolutely useless,
but stuff like this is driving me mad :-)
Merge branch 'userscript_loader'.

This implements a more-or-less good chainloader. I'd prefer to go with the
userscript compiler, but unfortunately it won't get finished in an acceptable
time, so we go with a solution that's not the worst one but definitely not very
slick or neat.

So, here it is and it's implemented using a series of macros which do two-step
compilation:

Step 1:
- Compile the real code into cncta.js.
- While compiling the code, a macro is run which generates cncta.user.js,
  which in turn only contains the userscript meta info and some token.

Step 2:
- Compile the preloader code based on the contents of cncta.js.
- Replace the token in cncta.user.js with the preloader and the real code.

Unfortunately this tremendously increases compile time. But for now, I'm fine
with that and it can be optimized later (for example by escaping in one single
pass).

So, now the positive points of this implementation: We can finally access the
"webfrontend" namespace from the game! And in addition, we are no longer
depending on sed and echo, so it should compile well even on Windows.