awaits/watches

1. reverted to the model where awaits may be called multiple times per commit
if multiple member boxes are updated during the transaction. True atomicity
would require bringing all member boxes into the transaction, which is a non-
goal. The right abstraction for awaits() is disjunction: the predicate should
be a strict or over one subtest per member value. The only sense in which awaits()
draws the boxes together is that a change to any box will wake up the thread and
run the test. TODO: once we have type-level zip, awaits should be modified to
have the following param signature:

    <Ts> awaits(boxes : Tup(Ts | Box), preds : Tup(Ts | Pred)) -> ...

This will enforce the disjointness of the tests.

2. Per the above, watches is gone, since given the lack of atomicity guarantee
over the whole incoming tuple, a call to watches() could always be replaced by
calls to watch() over the member boxes.
Merge remote-tracking branch 'upstream/master' into await
Await/awaits supplemental work/fixes

1. correct if() to while() around wait() calls

2. change awaits() args sig: was

    Tup(T | Box), Tup(T) -> Bool // single pred takes tuple of values

is now

    Tup(T | Box), Tup(T | Pred)  // tuple of preds, one per box

...this avoids the misunderstanding that predicate calls are in any
sense atomic on the aggregate of boxes.

3. remove legacy Types.unit()

4. add typedef Pred(T) = T -> Bool

5. tweak CG pipeline to use type.eval() where necessary.

Note: #5 is more ad-hoc than it should be. Reconciling type
reduction and evaluation remains a big TODO.