Enable decoupling of parent/child data fetching
Right now, resolvers can be defined for types as shown in [the documentation](https://www.apollographql.com/docs/apollo-server/data/resolvers#example):

```ts
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

const libraries = [
  {
    branch: 'downtown',
  },
  {
    branch: 'riverside',
  },
];

// The branch field of a book indicates which library has it in stock
const books = [
  {
    title: 'The Awakening',
    author: 'Kate Chopin',
    branch: 'riverside',
  },
  {
    title: 'City of Glass',
    author: 'Paul Auster',
    branch: 'downtown',
  },
];

// Schema definition
const typeDefs = `#graphql
  # A library has a branch and books
  type Library {
    branch: String!
    books: [Book!]
  }

  # A book has a title and author
  type Book {
    title: String!
    author: Author!
  }

  # An author has a name
  type Author {
    name: String!
  }

  # Queries can fetch a list of libraries
  type Query {
    libraries: [Library]
  }
`;

// Resolver map
const resolvers = {
  Query: {
    libraries() {
      // Return our hardcoded array of libraries
      return libraries;
    },
  },
  Library: {
    books(parent) {
      // Filter the hardcoded array of books to only include
      // books that are located at the correct branch
      return books.filter((book) => book.branch === parent.branch);
    },
  },
  Book: {
    // The parent resolver (Library.books) returns an object with the
    // author's name in the "author" field. Return a JSON object containing
    // the name, because this field expects an object.
    author(parent) {
      return {
        name: parent.author,
      };
    },
  },

  // Because Book.author returns an object with a "name" field,
  // Apollo Server's default resolver for Author.name will work.
  // We don't need to define one.
};

// Pass schema definition and resolvers to the
// ApolloServer constructor
const server = new ApolloServer({
  typeDefs,
  resolvers,
});
```

However, this is awkward if the parent resolver only defines the ID of the child, e.g. see the `bookField` usage below:
```ts
import { ApolloServer } from '@apollo/server';
import { startStandaloneServer } from '@apollo/server/standalone';

const libraries = [
  {
    branch: 'downtown',
    books: [{id: '1'}, {id: '2'}]
  },
  {
    branch: 'riverside',
    books: [{id: '1'}]
  },
];

// The branch field of a book indicates which library has it in stock
const books = [
  {
    id: '1',
    title: 'The Awakening',
    author: {
      name: 'Kate Chopin',
    },
    branch: 'riverside',
  },
  {
    id: '2',
    title: 'City of Glass',
    author: {
      name: 'Paul Auster',
    },
    branch: 'downtown',
  },
];

// Schema definition
const typeDefs = `#graphql
  # A library has a branch and books
  type Library {
    branch: String!
    books: [Book!]
  }

  # A book has a title and author
  type Book {
    title: String!
    author: Author!
  }

  # An author has a name
  type Author {
    name: String!
  }

  # Queries can fetch a list of libraries
  type Query {
    libraries: [Library]
  }
`;

const bookField = field => ({id}) => {
  const book = books.find(book => id === book.id);
  return book[field];
}

// Resolver map
const resolvers = {
  Query: {
    libraries() {
      // Return our hardcoded array of libraries
      return libraries;
    },
  },
  Book: {
    // We have to define each field here or they won't show up
    title: bookField('title'),
    author: bookField('author'),
  },
};

// Pass schema definition and resolvers to the
// ApolloServer constructor
const server = new ApolloServer({
  typeDefs,
  resolvers,
});
```

The above example can be used if the parents establish referential relationships to the children, and the children define their own fields. This does work, but it's awkward (you have to remember to define each field individually) and computationally inefficient (you need to recompute each field separately, although caching can mitigate this issue somewhat).

What I would like to see is the ability to define something like:
```ts
Book: {
    __resolveValue: (({id}) => books.find(book => id === book.id)),
},
```

Where `__resolveValue` works like any resolver, but resolving the value of the whole type. This follows the pattern of `__resolveType`, but for values. This is helpful because it allows us to decouple parent and child data fetching without having to define fields individually.