Add an example of structural subtyping to define so-called "refinement" types.
Set up an example where we could use structural subtyping to consolidate code.
Add a broken example of one attempt to define a generalized 'using' function.

This attempt almost works, but it will get a type error where close() is
called. The problem is that, as written, T can be any type at all. To
indicate that it only really supports types with close() methods,
the <: notation can be used to give an upper bound to T. In this case,
the desired upper bound is

{ def close(): Unit }.

Let's see the next commit for a complete working definition.
Use a structural type upper bound to define a proper 'using' function.

Now, the type checker knows that we can call using on any object of type
T that is a subtype of a type that defines a function of type 'close(): Unit'.
Remove no-longer-needed casts, abstract class modifier.

Now that using has been properly defined, these cast operations are
redundant. The right type definition has been found; 'using' can take
any object that is "close()"-able, which is the case for both PrintWriter
and ServerSocket/Socket.

With the 'using' method properly defined, the StructuralSubtyping class
no longer needs to be abstract either.