text: Title: Interfaces lead to circular imports when splitting type definitions across files
  Body: I'm not sure if this issue has been raised before. Did a quick search through issues and didn't find anything. But I was wondering if anyone had run into this issue before and there's an existing Python solution I'm not thinking about or if this is an existing issue.
  
  Basically, when defining a type that implements an interface, we specify the interface class that is being implemented by this new type in the Meta interface option.
  
  ```
  class Character(graphene.Interface): 
      id = graphene.ID(required=True)
      name = graphene.String(required=True)
      friends = graphene.List(lambda: Character)
  
  class Human(graphene.ObjectType):
      class Meta:
          interfaces = (Character, ) # <----- here
  
      starships = graphene.List(Starship)
      home_planet = graphene.String()
  
  ```
  
  But if we would like to split the class definitions across two files:
  
  ```
  #schema.py 
  
  import graphene
  from human import Human
  from droid import Droid
  
  
  class Character(graphene.Interface):
      id = graphene.ID(required=True)
      name = graphene.String(required=True)
      friends = graphene.List(lambda: Character)
  
     def resolve_type(cls, instance, info):
          if instance.type == 'DROID':
              return Droid
          return Human # <----- here we need to import Human
  
  
  
  
  ....
  
  
  schema = graphene.Schema(query=Query, mutation=Mutation, types=[Human])
  ```
  
  and
  
  ```
  #human.py
  class Human(graphene.ObjectType):
      class Meta:
          interfaces = (Character, ) # <--- would require us to import Character
  
      starships = graphene.List(Starship)
      home_planet = graphene.String()
  ```
  
  then how would the `Human` class be able to import the `Character` class it needs to specify in the interfaces it implements without introducing circular imports?