Serialization opt-in syntax (again)

[Brian Goetz]

I put all the candidate syntaxes so far in the JIRA issue for this, but 
a new one came to light this week that we kind of like.

The problem is: let's say you have a SAM that is not serializable, but 
you want the instance to be, such as in:

   Runnable r = () -> { };

The problem is that we really want to specify multiple interfaces for 
the lambda, and as long as their intersection has only one abstract 
method, that should be OK.

So, how about using the space between the closing paren and the arrow:

   Runnable r = () implements Serializable -> { ... }

As a bonus, if we wanted to be explicit about all the implemented 
interfaces, this easily extends to:

   Object p = (String s) implements Predicate<String>, Serializable -> { 
... }


This also extends nicely to inner class creation expressions.  Right now 
there is a limit of one named supertype.  But this could be extended:

   Predicate<String> p = new Predicate<String>() implements Serializable 
{ ... }

In this case, there is no single-method restriction; you could implement 
Iterator and Runnable if you wanted:

   new Iterator<T>() implements Runnable { ... }

Note that none of this is serialization-specific; it is simply a way of 
being explicit about multiple supertypes in contexts there this was not 
previously allowed.