addTypeResolver() should accept InterfaceTypeComposer as type parameter

Currently the `addTypeResolver()` method is defined as:
```js
addTypeResolver(
type: ObjectTypeComposer | GraphQLObjectType,
checkFn: InterfaceTypeComposerResolverCheckFn
): this
```
But since interfaces can implement others, the `resolveType` method of an interface should allow to resolve an interface type too.

Minimal example:
```js
const PersonTC = schemaComposer.createInterfaceTC({
name: 'Person',
fields: { name: 'String' }
})

const EmployeeTC = schemaComposer.createInterfaceTC({
name: 'Employee',
interfaces: ['Person'],
fields: { name: 'String', title: 'String' }
})

const TeacherTC = schemaComposer.createObjectTC({
name: 'Teacher',
interfaces: ['Person', 'Employee'],
fields: { name: 'String', title: 'String', domain: 'String' }
})

const StudentTC = schemaComposer.createObjectTC({
name: 'Student',
interfaces: ['Person'],
fields: { name: 'String', year: 'Int' }
})

PersonTC.addTypeResolver(EmployeeTC, value => {
return value.hasOwnProperty('title');
});
PersonTC.addTypeResolver(StudentTC, value =>{
return value.hasOwnProperty('year');
});
EmployeeTC.addTypeResolver(TeacherTC, value =>{
return value.hasOwnProperty('domain');
});

const students = [{ name: 'Jean', year: 2020 }, { name: 'Albert', year: 2022 }];
const teachers = [{ name: 'Simon', title: 'Mr', domain: 'maths' }];
const directors = [{ name: 'Alfred', title: 'Mr' }];

schemaComposer.Query.addFields({
persons: {
type: '[Person]',
resolve: () => students.concat(teachers).concat(directors)
}
})

const schema = schemaComposer.buildSchema();

const req = `
{
persons {
name
... on Employee {
title
}
... on Teacher {
domain
}
... on Student {
year
}
}
}
`;

graphql(schema, req).then(res => {
console.log(JSON.stringify(res, null, 2))
})
```

According to the spec, it should work, but it ends up with:
```
Error: For interface type resolver Person you must provide GraphQLObjectType or ObjectTypeComposer, but provided InterfaceTypeComposer
```

If you have any idea about how to reproduce such a multi-level inheritance schema, it would be very welcome.
I tried to use `resolveType` parameter in `InterfaceTypeComposer`, but it needs a GraphQL type, and I don't think there is a "graphql-compose" way to get the GraphQL generated type from the interface or object composer.