Add an example of constructor pattern matching.

Constructors are where pattern matching becomes really powerful. A
constructor pattern looks like `BinaryOperator("+", e, Number(0))`.
It consists of a name (BinaryOperator) and then a number of patterns
within parentheses: "+", e, and Number(0).

Assuming the name designates a case class, such a pattern means
to first check that the object is a member of the named case class,
and then to check that the constructor parameters of the object match
the extra patterns supplied.

These extra patterns mean that Scala patterns support deep matches.
Such patterns not only check the top-level object supplied, but also
check the contents of the object against further patterns. Since the
extra patterns can themselves be constructor patterns, you can use
them to check arbitrarily deep into an object. For example,
the pattern shown here checks that the top-level object is a
BinaryOperator, that its third constructor parameter is a Number,
and that the value field of that number is 0.

This pattern just is one line long yet checks three levels deep.