This is a re-write of pychecker using traditional parse tree
techniques, rather than the bytecode.

There are some other design changes, related to Warning objects and
Option handling.  In general, pychecker2 tries to distribute checks to
separate classes.  These classes are more self-contained: they hold
onto the option variables and define the Warning objects they support.

Items still missing:
        Error suppression (errors may be suppressed globally)

        Typing of any kind:
             consistent return types
             consistent return styles (implicit and explicit)
             object members
             object methods

        New python features:
             slots
             properties
             integer division

        Complexity

        Doc strings

        Speed

Bugs:
        Is __file__ a builtin?
        locals() should use locals
        globals() should use globals
        exec may use locals/globals

        attributes defined from inherited classes from other modules 
           are treated as undefined

        class C:
              def f(a, b): pass
              def g(a, b): pass
              h = f
              h = g			# redef of h, not caught now

        foo = 1
        del foo	                        # should not be unused

        from __future__ import produces unused warnings
        import of readline has side effect on input/raw_input, and should be
           marked as used

Important stuff:

If you want to add new checks, there are some parts to be aware of:

        File
                A stupid data structure to hold everything we know about 
                a file to be checked.

                Members:
                   name
                        The file name.

                   parseTree
                        The root of the Abstract Syntax Tree returned from
                        compiler.parseFile.  Will be None if the file
                        won't even parse.

                   scopes
                        A dictionary of { node, scope } computed with
                        from compiler.symbols. For convenience, scopes
                        also refer back to the node and to the
                        enclosing parent scope (node and parent,
                        respectively).

                    root_scope
                        Convience for scopes[parseTree]

        Check
                Basic step for checking a file.  Usually contributes
                Warnings or additional information to File.  New checks
                will subclass this, and be added to the chain of checks
                given in main().

        Warning
                A description of a warning emitted by pychecker.


        Command line options are pulled from each check.
        A Warning is also turned into a boolean-style command line option.
