Initial commit
Adding the Memory Word implementation.
Some more of the store. The representation of types will have to change.
A first, core running emulator loop that can manipulate store nodes and registers.
Added cmake build files, and a KDevelop project file.

Build the VM with:
  mozart$ mkdir build
  mozart$ cd build
  build$ cmake ..
  build$ make

Then execute it with:
  build$ ./vm/src/vm
Added the error-free path for the builtin adding two integers.
Wrap builtins inside BuiltinProcedure values, instead of opcodes.
Explicitly use native integers in MemWords.
Move K registers inside CodeArea.
Abstractions (proc values), non-builtin calls, Y regs allocation.

Concretely, now the emulator is able to call user-defined procedures in addition to builtins.
Added a copiable flag in Type.

A type is copiable if copying a value of this type only requires to copy the node contents.

One example of copiable type is SmallInt. An example of non-copiable type is Abstraction.
Add References and Unbounds.

Optimized (sequential) unbounds only. They are used to write functions, for example.
Major refactoring.

Now the types and their implementation have an architecture close to the final one.
Added build instructions in the readme.
Add overflow checks in SmallInt + SmallInt.
Builtins are stored in K registers, and OpCallBuiltin expects a K register.
Boolean values, (un-)conditional branches, and == for SmallInt.

With these ingredients, tests like
    if N == 0 then
are possible.

The hardcoded program in main.cc now computes the Nth Fibonacci
number. N can be configured in a constant near the top of the file.
Small code moving.

Calls to callBuiltin and getCallInfo are now directly inside Thread::run().

Previously they were 'pseudo-builtins', which was a bug in the design.
Fixed small bugs.
Rename opcode OpPrintInt into OpPrint, and it can display Boolean values.