Module variables are the primary key to the database.  Some somewhat anonymous
objects are hung off of module variables (types, classes, etc.)

Module variable:
    Kind: {Variable, Constant, Macro, Undefined, others?}
          The syntactic class of this variable.  Has it been defined yet?
    Type: Type of value.  If a function, includes information about arg/result
          types.
    Where-from: {Defined, Declared, Assumed}
          Where did we get the type/kind information from?
    Inline-expansion:
          The inline expansion lambda for a function, if any.
    Inlinep: {Inline, Notinline, Maybe-Inline, #f}
    Methods: If a GF, signatures of all defined methods and possibly their
             definitions. 
    Sealed: info about what parts of this GF are sealed.
    Macro-function: Macroexpander function, if a macro.
    Side-effects: is this a pure function?
    Optimizers: any optimizers (compiler macros, transforms, etc.)
    Accessor-for: If a slot accessor, for what class?
    Constant-value: If a compile-time constant, this is the value.

Objects that live in the compiler's database:
    Method definitions (inline expansions and macro expanders)
    Types: 
        Limited types (integer subranges, etc.), union types.
        Function types (arg/result signatures)
        Classes (inheritance and slot information, superclasses, subclasses,
                sealed) 
    Method-list: 
        a list of the compile-time information about the methods for a GF,
        potentially including specializers definition, side-effects, and
        anything else we want to know about arbitrary functions.