Switch labels (null again), some tweaking

[Brian Goetz]

The JEP has some examples of how the `null` case label can combine with 
others.  But I would like to propose a more general way to describe 
what's going on. This doesn't change the proposed language (much), as 
much as describing/specifying it in a more general way.

We have the following kinds of switch labels:

     case <constant>
     case null
     case <pattern>
     default

The question is, which can be combined with each other into a single 
case, such as:

     case 3, null, 5:

This question is related to, which can fall into each other:

     case 3:
     case null:
     case 5:

We can say that certain labels are compatible with certain others, and 
ones that are compatible can be combined / are candidates for 
fallthrough, by defining a compatibility predicate:

  - All <constant> case labels are compatible with each other;
  - The `null` label is compatible with <constant> labels;
  - The `null` label is compatible with `default`;
  - The `null` label is compatible with (explicit) type patterns:

(There is already a check that each label is applicable to the type of 
the target.)

Then we say: you can combine N case labels as long as they are all 
compatible with each other.  Combination includes both comma-separated 
lists in one case, as well as when one case is _reachable_ from another 
(fall through.)  And the two can be combined:

     case 3, 4: // fall through
     case null:

So the following are allowed:

     case 1, 2, 3, null:

     case null, 1, 2, 3:

     case null, Object o:

     case Object o, null:

     case null, default:    // special syntax rule for combining default

The following special rules apply:

  - `default` can be used as a case label when combined with compatible 
case labels (see last example above);
  - When `null` combines with a type pattern, the binding variable of 
the type pattern can bind null.

The semantics outlined in Gavin's JEP are unchanged; this is just a new 
and less fussy way to describe the behavior of the null label / specify 
the interaction with fallthrough.