The combos tests check whether one type of tree node correctly handles
instrumented children.  There are four different combinations:
	1. parent instrumented, child instrumented
	2. parent instrumented, child not instrumented
	3. parent not instrumented, child instrumented
	4. parent not instrumented, child not instrumented.

Case 4 is tested by the tree-no-op tests. 
It would probably be sufficient to simply test case 1, but the
additional cases are cheap to test.

These tests all revolve around these two USE test conditions:
	- the child does not change its root node.
	- the child does change its root node.

It is very unlikely that the *kind* of change is relevant, so we cycle
though these:
	expressions:
4		relational
2		funcall with call on
2		funcall with race on
1		funcall with call and race on
	statements (only these affect the root node)
2		return (with race coverage)
1		do	(loop coverage)
2		while	(loop coverage)
1		for	(loop coverage)

Here are the parents of interest and their children.  Some could be
omitted, because covered by other tests, but finding those would be
more trouble than worth.
1	default, a following statement.
1	case, a following statement
1	switch, the test expression
1	switch, the body (OMITTED - the only case would be a non-compound body)
1	for, the test expression  (loop and branch on)
1	for, the body
1	do, the test expression	  (branch only)
1	do, the body
1	while, the test expression  (loop only)
1	while, the body
1	quest, the test expression
1	quest, the true case
1	quest, the false case
1	if, the test expression
1	if, the true case
1	if, the false case
1	assign, the right-hand side
1	boolean, the left side 
1	boolean, the right side
1	relational, the left side
1	relational, the right side
	return, the returned expression
1	funcall, the function itself (no instrumentation applies to funcall)
1	funcall, the first argument (no instrumentation applies to funcall)
1	funcall, the second argument (no instrumentation applies to funcall)
