Computes and prints the covariance matrix.
Writes the cluster tree as an output.
Adds category labels to the rules of a makeflow.

Labels are assigned according to the name of the variable in the
macro MAKEFLOW_TASK_CATEGORY (which right now is
"MAKEFLOW_TASK_CATEGORY").

For example:

one: src
	cmd

MAKEFLOW_TASK_CATEGORY="buzz"
two: src
	cmd

three: src
	cmd

four: src
@MAKEFLOW_TASK_CATEGORY="potatoe"
	cmd

five: src
	cmd

MAKEFLOW_TASK_CATEGORY="woody"
six: src
	cmd

MAKEFLOW_TASK_CATEGORY="buzz"
seven: src
	cmd

assigns the following categories (here naming a node by its output):

                     buzz: two, three, five, seven
                  potatoe: four
                    woody: six
without_explicit_category: one

A category is represented internally with a dag_task_category,
which keeps the label, and the member count.
Simplifies the creation of makeflow categories.
This fixes the infamous lcg-ls bug [1] introduced by commit

fe89bc527c3f2ace3144f04a78919ab5445cefe4

which was trying to resolve an identity boxing bug:

commit fe89bc527c3f2ace3144f04a78919ab5445cefe4
Author: dthain <dthain@nd.edu>
Date:   Fri Apr 20 12:40:07 2012 +0000

[Bug Fix] pfs_dispatch should convert [tg]kill calls into a dummy,
because the signal is actually delivered by pfs_process_raise.
This fixes a bug in which processes in an identity box could
send signals to those outside the box.

In actuality, the signal is not sent by pfs_process_raise and so the
signal is never delivered because (a) the *kill system calls are
converted to dummies and (b) SYSCALL_tgkill and others do not set the
"really_sendit" flag when calling pfs_process_raise. The fact that
pfs_process_raise does not send the signal is actually easy to miss.
Parrot claims in debug output the signal is sent but it does not. You
have to either double check the code or strace parrot (which I did).

This comment above the *kill system calls says what the right behavior
is:

/*
Note that we call pfs_process_raise here so that the process data
structures are made aware of the signal propagation, possibly kicking
someone out of sleep.  However, we do *not* convert this call to a
dummy, so that the sender can deliver itself, thus getting the correct
data into the sa_info structure.
*/

The bug with identity boxing may now (again) exist but I think the real
reason the fe89bc527c3f2ace3144f04a78919ab5445cefe4 commit fixed the
bug:

"This fixes a bug in which processes in an identity box could
send signals to those outside the box."

in the first place was because parrot processes now cannot send signals
at all! :D I have made a passing attempt at resolving this issue by
wrapping one of the kills with a "really_sendit" check, but that may
not be correct.

Anyway, this resolves the hang but there are still issues I think
continue to exist in the way parrot handles threads, at least for this
example. For some reason threads' system calls were not caught by Parrot
but this apparently was a phantom symptom, not really causing the actual
hang. We should revisit clone handling to correct this problem. Running
strace on strace is informitive on the latest quircks of handling
threads appropriately. There is also a feature in ptrace that allows
the tracer to set "options" to automagically follow children of the
tracee without needing to modify clone arguments.

[1] https://listserv.nd.edu/cgi-bin/wa?A2=ind1302&L=CCTOOLS&F=&S=&P=4034
Merge branch 'master' of github.com:cooperative-computing-lab/cctools
Fixes a couple of syntax errors.

(Last commit I forgot to stage some changes.)
Merge branch 'master' of github.com:cooperative-computing-lab/cctools