Added basic support for loading programs in memory.

I am in the process of implementing operations that are actually objects in the
system. I am deciding whether the initial implementation should be
message-based (requires a subclass for each operation and a general pain in the
ass with the upside being that its easy to write "microcode" if I want to get
that low level) or using a common operation class that asserts facts which
contain the actual operation logic. I'm not sure which one to do at this point.
I'm leaning towards the more "pain-in-the-ass" method because its easier to
understand and I can rearrange encodings without having to change execution
rules. The only downside is that the "overhead" of message passing could come
into play. However, this is not a safety-critical or performance tool so who
cares....hmmmmmm

Anyway, I have also implemented a cacheless design for the processor due to the
way that the knowledge base works combined with the fact that it is dead
fucking simple to implement. Caches add a lot of complexity that really is not
necessary at this point.
Started defining the instruction set.

The instruction set is unique in that there is only one instruction that can
operate with immediates. Every other instruction operates exclusively on
registers. This has the side effect of writing programs in assembly a pain in
the ass. It also has a positive side effect of making it really easy to change
operations internally to speed them up.

For example,

set r134 1
add r212 r39 r134

would be compressed internally to

add r212 r39 1

or something similar when the program is running. This is legal because
this instruction is never found in user program and would have a very
different meaning. In fact, encoding {add} 212 39 1 would yield:

add r212 r39 r1

by the decoder.

However, at this point I just want to see if I can get the processor working
and executing programs before moving onto runtime optimization techniques.
Added more decode rules

They're basically the same rule but with a different target. I will need to
eventually automate the process but at this point im not sure what would be the
best way to do that.
Added a README for the theoretical assembler
Added the start of an assembler for the theoretical processor
Added basic error checking for the assembler
Fixed a bug with the assembler
Moved common components to MachineCommon.clp
Added the automation to the bottom of Simulator.clp
added some more notes to the assembler
Moved the simulator components to the sim folder