Federation doesn't support fragment query against a referenced entity that satisfies an interface

If I have Service A, which defines entity `Cat`:
```
interface Animal {
id: ID!
}

type Cat implements Animal @key(fields: "id") {
id: ID!
meows: Boolean
}
```
And Service B, which duplicates the interface, and also provides entity `Dog`:
```
interface Animal {
id: ID!
}

type Cat @key(fields: "id") {
id: ID!
}

type Dog implements Animal @key(fields: "id") {
id: ID!
barks: Boolean
}

extend type Query {
animals: [Animal]
}
```
In Service B, we've marked `Cat` as a referenced entity. We've also made a `Dog` that satisfies the same interface.

Service B provides an aggregate query field: `animals`. This should be able to return any entity that satisfies the interface. If Service B creates stubs of `Cat`s in the return value of `animals`, they should resolve to Service A to load each `Cat`.

**Actual behavior**
In this setup, both services come up, and they compose properly. However, when trying to perform this query:

```
animals {
id
...on Cat {
meows
}
...on Dog {
barks
}
}
```

It raises a runtime error:

> Fragment cannot be spread here as objects of type "Animal" can never be of type "Cat".

Even though `Cat` satisfies the interface, its seems like the gateway is getting the `Cat` type entirely from Service B. The gateway thinks `Cat` doesn't satisfy the interface.

**Expected behavior**
- The query should go through with this setup and not error
- Animals should be able to return an array of Dogs, mixed in with an array of Cat stubs and their IDs
- Federation kicks in and the reference resolver in Service A fills in the missing Cat fields

Recreate the two-service federation setup from the issue and run the animals query with inline Cat and Dog fragments. Start by tracing how the gateway represents the referenced Cat type and its Animal interface; done means the query validates, mixed Cat stubs and Dogs are returned, and Cat fields resolve through Service A.

Written by the indexing model from the issue text.