Added modified path builder

This new path builder will build paths for  loops as well as detect cycles. If
a block has been previously visted by the current path then the path is closed
with the exit block either being the loop itself or the block that has already
been visited for loops and cycles respectively
Updated stage registration to refer to extra stages that have been added

these new stages are meant to attempt to streamline the process of merging
loops and regions
Fixed the stages prior to pathing to support loops and cycles

It turns out that the issue stems from the fact that the parents of regions
were not being updated properly. This has been fixed by adding in rules that
assert facts that describe what the original parent of each region (including
loops) and during fixup rename will assert a fact describing the changes
necessary in parentage. The update will only occur if the region to be modified
is a region and not a loop.

A new stage will have to eventually be added which goes through after fixup is
completed and remove any elements from the Contents multislot of each region
which are not owned by that region.

To do this I had to add two new stages: FixupRegions (to correct the parentage)
and FixupProducers (to propagate region producers and also identify the set
of non local dependencies for each block).

Currently the code is still broken with respect to ordering loops and nested
loops.
Modified the set of rules in BlockDependencyCreation.clp

1) IdentifyRAW, IdentifyWAW, and IdentifyWAR have been replaced with a single
rule that iterates through the operands of a given instruction and creates
dependency information from that. This change alone significantly reduces the
running time of the scheduler. The reason for this speed boost is that the
previous method of dependency analysis was redundant. The set of operands for a
given instruction defines the exact set of dependencies that instruction has
scheduling wise.

2) Modified the rules having to do with call analysis. The rules for finding
instructions that occur _before_ a given call have been modified to actually be
_more_ procedural but also far more intelligent match wise as well. Instead of
looking through the set of call instructions (expensive) the rule first
captures a basic block (cheap) and iterates through the Contents until a call
instruction is found. The set of elements that occur before the call are
captured and iterated through in the body of the rule.

Both rules for pre-call dependencies have been fixed this way.

The rules for identifying instructions that follow a call have been modified to
use the same iterative method as the pre-call rules. The difference between the
two sets, beyond a logical understanding, is the fact that the post-call
rules do _not_ assert consumption facts for instructions. It was found that
this was unnecessary because the instruction is never going to be scheduled in
the current incarnation of the scheduler.

3) The first set of setify rules has been removed. Performing the operation
twice was found to be unnecessary. It would slow things down greatly.

All of these changes have dropped the running time on my test machine by 0.4
seconds on a small case. Originally the scheduler took 1.6 seconds on this test
code and now it only takes 1.2 seconds.

Also, it is important to note that the original versions of the rules are still
in the code because I may need to use them as reference in the future.
Obviously, they are commented out.
Removed commented out code from BlockDependencyCreation.

I realized that it was not necessary to keep it in there. I would never go back
to it because it is ridiculously inefficient.
Reformatted and corrected a incorrect doc string

I fixed the doc string for MarkCallInstructionDependency-SideEffects to not
just be a copy of MarkCallInstructionDependency-InlineAsm's docstring (which it
originally was)

I also reformatted the code so that it looks cleaner to
Modified the FrequencyAnalysis.clp to speed it up

I removed the need to check for the type of the frequency analyzer. I also
changed the order of evaluation for the Incrementation rule. The number of
blocks is checked first before actually binding to the FrequencyAnalysis
object.
Removed references to the SourceRegisters multislot

This is a duplicate of the Operands field and was causing a large amount of
duplication to occur. Consequently, this has been removed and all references to
the code has been replaced with references to Operands instead. Since
SourceRegisters and Operands contain the same data it should work the same.
The other change made is that the set of producers is no longer populated ahead
of time during object initialization. This was causing an unnecessary amount of
setification and as such has been removed. On the unoptimized version of flops
the running time dropped from 1.22 to 1.07 seconds!

Memory consumption should have also dropped due to the removal of the
unnecessary SourceRegisters multislot attached to each copy of the instructions
in a given function. However, this was not actually looked at during testing.
Fixed a bug with the previous commit dealing with source registers

There were still references to actions being performed on the SourceRegister
multifield even though it does not actually exist anymore. This will cause the
current run to abort because the send operation will fail to execute properly.
Added a type to an object match win ReplaceParentOfGivenItem

Originally I did not have an object type to match against. While this is valid,
the matching process _seems_ to be slower. I don't know if it is or is not but
I do not like having un qualified types at this point.
Condensed AddPathToBlock and AddPathToRegion

These two rules have been replaced by a single one called AddPathToDiplomat.
This not only removes a rule but also improves running time by about 9-15
seconds when schedulng clips!
Removed a significant number of rules in MemoryBarrierCreation.clp

I merged the separate rules to update blocks and regions into a single set to
operate on the Diplomat supertype.

This does not speed the code up but makes it easier to maintain
Updated BlockDependencyCreation.clp to reduce the rule count

I converted the rules for block and region analysis to a corresponding Diplomat
setup. This not only reduce the running time of the optimization slightly but
also makes the code base far easier to maintain if changes are necessary.
Modified MemoryBarrierCreation.clp further

1) I wrote rules to merge the reads from and writes to facts into one giant
fact to reduce the number of multifield rebuilds
2) I redid the MemoryTarget field update process to actually occur in the rule
where the fact describing the target was originally asserted. Obviously, this
means that the fact is no longer necessary. This also reduces the overall
runtime of the optimization as well.
Commented out the first instances of producer and consumer injection

I realized that running this operation twice is more expensive due to the fact
that more multifield rebuilds will be necessary.
Removed the commented out lines from PathBuilding.clp
Updated ProducersPropagation to match against _any_ non local dependency
Modified LLVMScheduleConstruction to not bind $?last

There were two rules where I was capturing the "rest" of a list but was never
using it. This has been fixed
Modified ValidBlockIdentification.clp to skip regions

Originally, regions were skipped after a fact was asserted to check it out.
This is completely wasteful, I added a check in AssertIdentifySpansInitial to
make sure that the current element is a basic block
Rewrote the Schedule constructor to not use instruction groups

Instruction groups were actually slowing things down. Instead, an instruction
stream is added to the Schedule object. This stream is updated instead of
separate instruction groups.

It seems to be faster too :D