Support lazy type references everywhere

**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:

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

but we can't have this:

```python
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 ](https://github.com/graphql-python/graphene/blob/master/graphene/relay/connection.py#L98-L100) and handle cases where the name isn't available [here](https://github.com/graphql-python/graphene/blob/master/graphene/relay/connection.py#L102).
- Interfaces are probably the biggest change since that will require the entire fields construction [here](https://github.com/graphql-python/graphene/blob/master/graphene/types/objecttype.py#L136-L151) to be moved to a property to be resolved lazily. Even then, it's conceptually very similar to the `Union` change above.

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.

Escrito por el modelo de indexación a partir del texto del issue.