Support lazy type references everywhere

Review graphene/relay/connection.py around the node type checks and name handling, and graphene/types/objecttype.py around fields construction. Use PR #1599 as the Union precedent. Done means lazy string or callable references work consistently for Connection node types, Union members, and ObjectType or Interface interfaces.

Is your feature request related to a problem? Please describe.

Currently, Graphene supports lazy type references (a string or a callable) in fields, input fields, and arguments. But there are other places where types are coupled that don't support it. From what I can tell, it's these cases:

• Node types of a relay.Connection
• Member types of a Union
• Interfaces of an ObjectType or another Interface

Lazy references are useful for modelling schemas with circular dependencies across multiple Python modules without creating circular imports. But they're also useful for non-static schemas, which you might have when some relationships depend on configuration such as feature flags that aren't available at import time. For example, it's possible to do this:

class SomeType(ObjectType):
   field = Field(lambda: OneType if CONFIG.get_feature_flag() else AnotherType)

but we can't have this:

class SomeUnion(Union):
    class Meta:
        types = (lambda: OneType if CONFIG.get_feature_flag() else AnotherType, ...) 

Overall, it's a bit unintuitive that lazy references are allowed in some places but not others.

Describe the solution you'd like
Support lazy type references consistently across all type declarations, including in the three cases described above.

Describe alternatives you've considered
For circular imports, it's usually possible to break dependencies elsewhere in the chain where lazy references are already supported. Though there may be some more contrived cases that only involve the relationships described above, where this wouldn't be possible.

For dynamic schema parts, you could define all schema components at runtime rather than statically, but in practice I think the static approach is cleaner in most cases and makes it easier to distribute schema components across multiple modules.

Additional context
I don't expect the changes to be huge, they should be non-breaking, and I'm happy to contribute them if people find this useful.

• I've already prepared a PR for adding support to Union types: #1599
• Supporting node types for Connection should be easier. The node construction already supports lazy references, we'd just need to remove the hard-coded instance check and handle cases where the name isn't available here.
• Interfaces are probably the biggest change since that will require the entire fields construction here to be moved to a property to be resolved lazily. Even then, it's conceptually very similar to the Union change above.