Building some targets serially, others in parallel

[dan soucy]

Hi list.

I find myself in a situation where I want the makefile to know not to build
certain targets in parallel, even though they do not actually depend on each
other. 

To explain: 

Suppose we have three executables to build: `server`, `client`, `demo`. Each
of these has an associated source file.

There are many other source files -- maybe a dozen. They will be compiled to
object files which are depended on by all three executable files.

Normally, the quick solution is to add one target for each object file and 
tell `make` to invoke the compiler on each in a separate process, using as 
many processors as are available.

But -- in this case, the design of the compiler is such that telling the
compiler to build all required object files in parallel is much faster than
invoking the compiler many times. This is due to a (relatively) slow start-up 
and also the re-use of data between source files (such as types).

So instead, we have something like this:

```
server client demo: $(OBJECTS)
    $(COMPILER) -j 4 $@ -o $< 
```

Running `make -j 4 server client demo` with the object files not built will 
result in the compiler being invoked thrice, and each will begin by compiling 
the same object files. The result is that this actually takes longer than 
running `make` serially.

However, if the object files are already built, then `server`, `client`, and
`demo` can be built faster in parallel.

For the curious, the compiler is GHC and the code is Haskell.