Allow an indication of side-products of theory builds

Basically, write something like

foo: *theorynameScript.sml

to indicate that foo will be built when the theory theoryname is
built. As part of the process, provide much better testing of the
parallel execution of multiple target rules and completely change the
way these are handled.

In particular, the dependency graph that Holmake maintains now does
not have multiple targets for a single node, but instead makes sure
that when a command is executed for a single target, all nodes that
would execute the same command are considered to be running at the
same time, and get the same success/failure status when the command
finishes.

Needs documentation, but is progress with Github issue #429

Fix early-termination of multi-command blocks when doing relocbuild

Make multibuild Holmake pass on reloc environment variable

Rebuild .uo and .ui files without forcing unnecessary extra work

This is by analogy with what has already been attempted for heaps, and
is progress with github issue #105.

Also fix a bug with the heap handling if the heap was in a
directory with script-files (not the case with the heaps in HOL/src):
the dependency graph built for the directory spotted that there was a
dependency from the heap to the script files, and even though the
heap's time-stamp was set appropriately, the existence of the link in
the graph meant that the rest of the graph got executed.

The fix for this (in both the case of the heap and the .uo/.ui file)
is for execution of graph nodes to check at the time the node is made
ready to execute if the target really does need to be redone (by
examining time-stamps). Then, the rebuild can be skipped even though
the initial analysis thought it was going to have to happen.

Future work:
- For the moment, both build and Holmake rely on having a particular
environment variable set to enable this option. I will augment
and/or replace this with command-line options. (The buildheap
program needs to retain this use of the environment variable though
because neither Holmake nor build control how that program is
called; instead this program is called by the user via
Holmakefiles.)
- Build needs to take an option to clean a HOL installation of its
heaps and ui/uo files. I don't know how to automatically identify
the heaps, but could just purge those that are identified as such in
Holmakefiles.

Allow users to specify time-limit on command-line

Thus,

Holmake -t10

will kill any sub-process (e.g., a script file running) that doesn't do
anything (= produce any output) for 10 seconds.

Allow monitors to kill over-stalled processes

API allows for it, but no way to set a non-NONE value so far.

Handle opentheory tgts when building in parallel

Move monitoring code out of multibuild

This separates fancy, possibly ANSI-based, monitoring output from the
logic of running builds over dependency graphs.

Refactor a little in multibuild's monitoring code

Clear multibuild output to end-of-line (prettier)

Copy script output in multibuild when just 1 job running

When multiple scripts are going at once, the whirling single character
is all that can fit, but when there is just one job, we now see the last
line of its output as it runs.

Make Holmake output lose ANSI-guff when not to tty

Thanks to Rob Arthan for implementation of function that detects if an
output stream is a tty.

Emit CHEAT when non-qof tactic fails; get nice colours

By having the tactic cheat, and the non-qof handling of prove both emit
the string "CHEAT" as part of their behaviour, Holmake's multibuild can
give you a CHEATED verdict on scripts that do either. Strictly,
speaking the tag attached to non-qof failure is not cheat, but I don't
think that's really important here.

Make multibuild spot "CHEAT" msgs from thy build

Then it can print a green CHEAT verdict for the theory as a
whole (contrasting with OK). Should also look into detection of failed
proofs that get accepted in absence of --qof flag.

Make building thys print without "Theory" suffix

This will let more of the real name fit into the little 16-char wide
column used when up to four things are going at once. Logic that
detected this situation needed changing in face of 1a3b26f (it's now
much simpler).

Simplify the output of multi-build.

For example: `xTheory.sig xTheory.sml` is now `xTheory` and `x.ext1 x.ext2` is now `x.{ext1,ext2}`.

Stop tagging stderr output specially in log files

Make parallel Holmake's output prettier

When a process fails, a chunk of its output up to the failure point is
output to the main screen. Also, a process that is killed because of a
general desire to give up (a failure elsewhere and no -k option, say),
now gets a red M-KILLED ("monitor killed") report.

Make Holmake output prettier (including colours)

Make multibuild output prettier

Finish implementing multibuild for Poly/ML Holmake

It doesn't yet look as pretty as I'd like it, but the basic
functionality is there. The default parallelisation is 4-way. If you
want the old behaviour and look, call Holmake -j1

Make multibuild honour leading - character in cmds

If you write

-do something

then it doesn't matter if this line fails.

Enable multiplexed builds for Poly/ML

Output is horrendous at the moment

Write some uncalled code to use multiplexing

The code compiles but that's all