Recursion guard in RubyObject#lookup.

This prevents the lookup method from entering an infinite loop when performing
lookups in recursive data structures.

Two examples of this are Logger and Logger::Severity. Logger includes the
Logger::Severity module which in turn should inherit from the Logger module. As
an example, take the following snippet:

    class Example < Logger
    end

When trying to perform some kind of lookup on the Example class, e.g. an
instance variable, the following lookup path would be used:

    Example -> Logger -> Logger::Severity -> Logger -> Logger::Severity -> etc

This is due to the Logger definition specifying Logger::Severity as a parent
with the latter doing the same but in the opposite manner.

The recursion guard in this case keeps track of parent definitions already used
in a lookup and skips these. It's a bit dirty that this is even needed in the
first place. Once again I'll have to look into alternatives for the current
definition system. Perhaps I should resort to performing live lookups based on
the current environment again as earlier ruby-lint versions did.

This fixes #108.