Fixed a typo: part of define-generics's documentation was in the wrong scope.
Keyword arguments to define-generics can be in any order, before/after methods.
Added tests for varying the order of keyword options to define-generics.
Documented the new argument order accepted by define-generics.
Removed #:prop-defined-already? option from private define-generics macro.

In the few cases that used this option, the only definition needed from the
private define-generics macro was gen:<name>.  This is easy to define directly
without using the macro, so I have changed the code to do so and avoid redundant
definitions of methods.
Renamed private version of define-generics to define-primitive-generics.
Separated generic contracts from define-primitive-generics.

Now the primitive generics form just defines generics with their properties and
methods, and the surface-level form calls the contract definition form
directly.  This means the primitive generics form now requires an explicit name
for a struct property accessor, so that the same name can be used for the
contract.
Added tests for "default" generic method implementations to work like #:methods.

Specifically, it should be possible for a "default" implementation to have
unsupported methods, and to use define/generic.
Adapted define-generics so that "defaults" work like #:methods implementations.

Specifically, implementations for the #:defaults keyword in define-generics can
now use define/generic to get at the generic implementation of a method for
which a specific implementation is defined locally.  Also, unimplemented methods
are handled properly now in #:defaults.  Previously, an unimplemented method in
a #:defaults specification would go into an infinite loop if applied, because
the implementation for the specific type wound up referring to the generic
implementation of the method.

A lot of the back-end implementation of generics changes in this commit:

- The new module racket/private/generic-methods provides a uniform mechanism for
  defining method tables and recording static information about generics
  groups.  Both #:methods in [define-]struct and #:defaults in define-generics
  use this framework now.  In addition, generics based on existing properties
  such as gen:stream, gen:equal+hash, and gen:custom-write now use the struct
  from this module to store the names associated with the generics groups.

- Generic methods now expand directly into functions with the appropriate arity,
  and refer directly to the appropriate argument to perform generic method
  dispatch.  The previous implementation used procedure-reduce-keyword-arity to
  restrict the arity dynamically, and used list-ref to find the generic
  argument.

- Some error messages have changed slightly; hopefully for the better, but this
  change did require some changes to tests for specific error messages.
Added tests for the behavior of generic methods.

Specifically, with the reorganization of racket/private/generic, different
method signatures (sets of required and optional, positional and keyword
arguments) exercise different paths in the code, at phases 0 and 1.  The tests
therefore include a variety of different method signatures.
Added a test for define/generic's interaction with marks.

Specifically, in the test, the bound name and the method name have marks on them
that are different from each other and from the original method names in the
enclosing generics group.
Added a #:fallbacks option to define-generics.

The #:fallbacks option specifies a set of method definitions.  Each definition
is used for any value that does not support the specific method.  Like
allows define/generic and absent method definitions.  If neither a specific
implementation or the #:fallbacks clause defines a given method, the normal
runtime error is raised.  The #:defined-table option reports whether a value's
specific implementation supports a method; the presence of a #:fallbacks
implementation for a method does not change this result.
Tests for the #:fallbacks option to define-generics.