Server doesn't correctly expose gateway defer directives
<!--

Thanks for filing an issue on Apollo Server!

Before reporting a bug, please first check for existing or closed issues
and read the instructions for filing a bug report:

https://github.com/apollographql/apollo-server/blob/main/CONTRIBUTING.md#reporting-bugs

### This bug report should include:

- [ ] A short, but descriptive title. The title doesn't need "Apollo" in it.
- [ ] The package name and version of Apollo showing the problem.
- [ ] If applicable, the last version of Apollo where the problem did _not_ occur.
- [ ] The expected behavior.
- [ ] The actual behavior.
- [ ] A **simple**, runnable reproduction!
      Please make a GitHub repository that anyone can clone and run and see the
      problem. Other great ways to demonstrate a reproduction are using our
      CodeSandbox template (https://codesandbox.io/s/apollo-server), or re-mixing
      our Glitch template (https://glitch.com/~apollo-launchpad).

  Please make sure that you include the following information to ensure that your issue is actionable.

  If you don't follow the template, your issue may end up being closed without anyone looking at it carefully, because it is not actionable for us without the information in this template.

-->

Configuring an apollo-server-express instance using the latest package versions of both `gateway` and `apollo-server`. I would expect that the server (which derives it's schema from the underlying gateway) to automatically allow clients to pass in `@defer` enabled requests, since there appears to be support within the gateway for `@defer` (I realize this is seemingly unpublicized behavior so maybe I'm getting ahead of the horse here).


Schema 1
```graphql
type User @key(fields: "id") {
  id: ID!
}

type Query {
  viewer: User
}
```

Schema 2
```graphql
type Query {
  group(id: ID!): Group
}

type User @key(fields: "id") {
  id: ID!
  groups: [Group!]!
}

type Group {
  id
  controls: [Control!]!
}

type Control {
  id: ID!
  label: String!
}
```

Ran `rover supergraph compose --config ./supergraph-config.yaml > supergraph.graphql`

With schema 1 and schema 2 as inputs within supergraph-config.yaml

```typescript
  const supergraphSdl = readFileSync(
    path.resolve(__dirname, '/supergraph.graphql')
  ).toString()

export const gateway = new ApolloGateway({
  supergraphSdl, 
  queryPlannerConfig: {incrementalDelivery: {enableDefer: true}}
})

const server = new ApolloServer({gateway, apollo})
```

Instead queries to the server that include a `@defer` block e.g.

```graphql
query {
  viewer {
    id
    groups {
       ... @defer { id, controls { label } }
    }
  }
}
```

Expected: Processes the query normally (internally deferring calls to the entities)

Actual: results in `"message": "Unknown directive \"@defer\".",`
