I have MM(P) working, the simplest form of Module Mutation. There are also hooks in
for MM(R) and MM(D), but they are not implemented yet. Details:

The number of brains that AgentBrain can now have is variable, and can depend on
the genome.

Mutation rates for MM(P), MM(R) and MM(D) are now part of the code, but I'm not
entirely happy with how I've set them up. Joel or Sebastian may need to fiddle with
them later to fit them into a place more appropriate/consistent with how NEAT params
are handled. Currently, each of these mutation rates are stored in NeatParameters,
because this is where all of the other mutation rates are. However, these are not
default NEAT mutations, so their default values are always 0. We are more likely to
want to modify these values on an experiment-by-experiment basis, which is why variables
for each rate are also stored in SimulatorExperiment.cs. Having the variables here
makes it easy to load them from the experiment xml file. However, the mutation rates
loaded from the experiment xml file have to be passed to the NeatParameters class
in order to be available during mutation, and this is done in a clunky way: In Experiment.cs,
there is a "get" for DefaultNeatParameters which actually transfers the mutation rates loaded
into the experiment to the NeatParameters instance. There is probably a much better way
to do this, but this works for now at least.

In order for Module Mutation to work, the NeuronGeneList has to support weird orderings.
Some operations require the genes to be ordered by innovation numbers (since binary sort is
used for lookup), but others require all output neurons to be clumped between the input
neurons and the hidden neurons. Therefore, this class sorts back and forth between the two
types depending on the operation needed.

Lastly, although the NeatGenome can handle the new Module Mutation operations, the new
modules will only function correctly in a network phenotype if the genome is decoded
correctly. Currently, the GenomeDecoder only correctly decodes NeatGenomes into a class
called ModularNetwork, which happens to be the type of neural network used in the experiments
that we are currently interested in. However, there are other types of neural networks, and
we should eventually make sure they decode multiple output modules correctly as well.