Planned module: @dataplan/graphql

### Summary
**Grafast Question: What is the best way to get or assemble the accessed fields from the finalized plan?**

HI @benjie, awesome work here! I'm excited for the future of grafast, its a novel solution to the continual pains of graphql resolution.

#### Example Case Question
Our team is writing a small service-specific graphql api wrapping our larger core graphql api. The schema will largely be a subset of the core schema, but with many fields filtered out and others added for denormalization / business logic. We've explored delegation, federation, and stitching, but all those seem rather bloated for our use case.

I was wondering if you have suggestions on using grafast steps to build up a dynamic query to another graphql server. I suspect this is theoretically very similar to pg planning.

Here is a somewhat contrived example schema for the service-specific api using grafast:

```typescript
const typeDefs = /* GraphQL */ `
type Query {
order(id: Int): Order
}

type Order {
id: Int
name: String
customer: Customer
}

type Customer {
id: Int
name: String
displayName: String
}
`

const plans: GrafastPlans = {
Order: {
id: ($order: ObjectLikeStep) => {
return $order.get('id')
},
name: ($order: ObjectLikeStep) => {
return lambda([$order.get('id')], ([id]) => {
return `Order #${id}`
})
},
customer($order: ObjectLikeStep) {
return $order.get('customer')
},
},
Customer: {
id: ($customer: ObjectLikeStep) => {
return $customer.get('id')
},
name: ($customer: ObjectLikeStep) => {
return $customer.get('name')
},
displayName: ($customer: ObjectLikeStep) => {
const $name = $customer.get('name')
const $region = $customer.get('region')
return lambda([$name, $region], ([name, region]) => {
return `${name} (${region})`
})
},
},
Query: {
order(_, fieldArgs, _builder) {
const $id = fieldArgs.get('id')
return loadOne($id, async (specs, options) => {
const someSelectFromAccessedFieldsInDag = {
// How to fetch full select here?
}
const query = jsonToGraphQLQuery({
query: {
order: {
__args: {
id: $id,
},
...someSelectFromAccessedFieldsInDag,
},
},
})
return client.execute(query)
})
},
},
}
```

And given the following example query to the grafast api:
```graphql
query order($id: Int) {
order(id: $id) {
name
customer {
name
displayName
}
}
}
```
That query assembles a plan with `$order.id`, `$order.customer`, `$customer.name` and `$customer.region`.

Given that, the desired query to the core graphql api would be:
```graphql
query order($id: Int) {
order(id: $id) {
id
customer {
name
region
}
}
}
```

What would be the best way to assemble the full set of fields accessed from the `Query.order` step? Can that be done by walking the plan itself, or do we need to use a custom step class to track and assemble the core api query?

Thanks!