Run for 900 generations

Added a few extra data to the log output and run against spinbot
Run for 5000 generations against spinbot

Previous run was bumping genetic diversity off the 2nd cousin incest limit; I've
changed back to a linear selection function and run for 5000 generations. It now
happily sits at around 2.5 and appears to be stable long term.
Removed run results

While I do want these to be included in the git repository, I don't want them
hanging around with code that didn't generate them as this is liable to cause
confusion.
Run for 9000 generations against superSpinBot

I terminated this run at 9000 generations because I had to power down the
computer to move to oxford. It achieved slightly below equal performance, but
had not definitively reached its final plateau
Run for 15k generations against SuperSpinBot

Same setup as before, but run until performance had clearly levelled off. Turns
out to be at about same level as before; the slightly about 50% score is
slightly misleading as this is the best of each generation therefore benefits
from the most favourable random fluctuation - they only tend to score a little
abouve the average of 25%ish.

I suspect that genetic diversity has been destroyed as the behaviour seems to
change very little once it has established the 'drive back and forth spinning
the gun and shooting when it sees an enemy' tactic.
Added log missing from previous commit
Rewritten mutations

Added breeding mutations, whereby the parent strings can be 'incorrectly' chosen
and assembled in the wrong order, and large scale mutations, whereby large
chunks can be deleted, repeated, reversed or moved.
Run for ~2k generations against SpinBot

Achieved a much quicker rise in performance than previous runs, also managed to
achieve a higher performance - running average of 97% with some 100% generations
Added extra digit to winner directories for over 10k generations
Calculate a maximum meaningful cousinality and set it as the maximum search depth
Added an instruction to prevent skipped turns as they have been causing problems
Changed monitoring output
Changed to using up to date version of robocode rather than the one in the repos
Restructured things to include a Generation class

The generation class encapsulates breeding plus a few other bits & bobs. I've
also fiddled with RobotBreeder a bit so that I can evolve parallel populations
easier; RB is still a bit of a mess that needs sorting out at some point.
Added population splitting

This breeds two independant populations for a number of generations, breeds two
new populations from the combined outcome then repeats indefinitely
Tweaked to allow archiving of all winners
Improved performance for large genomes

Previously genomes would grow very large and cause substantial slowdowns; I've
rewritten small scale mutations to be far more efficient and stopped
transcribing to java code except when archiving winners
Run for 6x2 populations of 1k generations

Discovered 2 main tactics; firstly the good old drive about in a not quite
circle while shooting, then full on ramming.

Stopped to try new version without memory leak that was discussed here:
https://sourceforge.net/p/robocode/discussion/116459/thread/1ab05bf1/
EvolveBot working value fix.

The commands that change the value of `workingValue` were not looking at the next value. `i++` returns the current value of `i`, then increments it. The fix was to change it to `++i`, which increments the value of `i`, then returns it.
GeneticCode working value fix

GeneticCode wasn't looking at the next gene when it had a command that expects a following value.