Added basic support for parse errors

Parse errors list the name of tokens or rules that were expected at the
point where they occurred. They also describe the state the parser was
in when it happened (for instance, if the error happened within a
local-statement, a method definition, or a record literal).

To achieve this, the grammar needs to be annotated with label(X Parser)
and context(X Parser).

This does have a very negative effect on parsing performance.
Parsing rules are now looked up at translate-time

The main purpose of this patch is to improve performance of the
parser. It does so significantly (and is in fact almost enough to make
the parser as fast as it was when it didn't handle errors).

Every time the parser encountered a non-terminal rule, it would look up
the procedure that needed to be called. Since this happens extremely
often, moving the code that does this to the time when the rules are
being translated (which only happens once) is very helpful.

Notice that this works even for mutually recursive rules when none of
them are yet defined thanks to unbound variables.

PEG.oz also allowed for each context to specify which grammar to
use. Since none of the current parsers used that feature, it has been
removed in the interest of simplicity and performance both (it could be
re-added with close to cost when it isn't being used with an option if
need be).
Disable caching for certain rules

The UseCache option the parser currently provides is an all-or-nothing
deal. However, Parser.oz is unacceptably slow when it is set to false
but very memory hungry when it is set to true.

This patch aims at providing a finer-grained control over this by
explicitly specifying some rules that do not benefit enough from caching
for it to be worth it. This usually increases parse time but reduces
memory usage.

The parser seems to perform acceptably without caching for the rules for
which it has been disabled, however more experimenting can still be done
to find for which rules the time gain isn't worth the memory expense.

(As a sidenote, I do not understand why caching pB is faster: that rule
is ran extremely often, but how can directly running it, seeing how
trivial it is, be slower than checking if it's in the cache and branching?)
Rewrote LookupRules using Dictionary.condExchange
Fix typo in Parser.oz
Merge pull request #209 from Mon-Ouie/feature/parse-error

Add parse error messages
update stdlib submodule pointer
Merge pull request #210 from sjmackenzie/master

update stdlib submodule pointer
Make it compile again on 32/64-bit Windows

* Mozart won't compile on 32-bit Windows because it requires lot of
contiguous memory and 32-bit max virtual memory is too small, so reduced
its max memory usage to 512MB
* The --eval of emacs command seems to do a mess when compiling. The -L paremeter do the same thing more simply.
* Tests couldn't be run because ozemulator is ozengine on Windows
* Updated CMakeLists to support x64 compilation on Windows
* Updated platform detection function call to allow 64bit Windows to be recognized
Updated Windows README

Nuwen's MinGW does not support 32-bit anymore, clang 3.4 does not seem to work
with MinGW and Boost...
Added icon for Mozart launcher on Windows

Just to give the shortcuts a better look...
Package icons and dependencies for Linux

* Added icons and desktop shortcuts for Linux
* Added lines for dependencies (may be modified by the packager) for DEB and
RPM packages
Added Inno Setup packaging method

* Retrieved ModifyPath.iss from Mozart 1 repo and updated it
* Added Inno Setup scripts with batch file to check Tcl version
* Modified CMakeLists to compute Inno Setup configuration
* Added make installer target on Windows to launch the process
* Updated Windows README to include setup making notice
Merge pull request #212 from anthonygego/master

Improved package distribution and Windows compilation process