consider flattening schema definitions in MUD config

[holic]

(related to #1668)

I want to propose moving away from keySchema and valueSchema and into a singular schema definition, e.g.

mudConfig({
  tables: {
    Position: {
      schema: {
        player: 'address',
        x: 'int32',
        y: 'int32',
      },
      key: ['player'],
    },
  },
});

This more cleanly maps to relational concepts (table schema with fields and a primary key) and reduces the number of new concepts we have to introduce about MUD (key schemas vs value schemas). This also maps well to the query API where "subjects" of a query are represented as field tuples.

query({
  from: {
    Position: ['player'],
  },
});

I recognize that this is maybe a little more confusing for folks used to our Solidity table libs, where the input args are keys and output is non-key fields:

(int32 x, int32 y) = Position.get(player);

But I think coming in with fresh eyes, this still makes sense and is a worthwhile trade-off. In Solidity, you don't want to pass around extra data because of gas, so you likely wouldn't return the same key fields you passed in as arguments.

For ECS usages, we'll likely have a plugin or some other wrapper to help you quickly define components as tables and automate setting up keys, etc.

[holic]

Using the MUD config in #2272 as an example

Before

const tables = {
  Position: {
    keySchema: {
      player: "address"
    },
    valueSchema: {
      x: "int32",
      y: "int32"
    }
  },
  Health: {
    keySchema: {
      player: "address"
    },
    value: {
      health: "uint256"
    }
  },
  Inventory: {
    keySchema: {
      player: "address",
      item: "uint8"
    },
    valueSchema: {
      amount: "uint32"
    }
  },
  Score: {
    keySchema: {
      player: "address",
      match: "uint256"
    },
    valueSchema: {
      score: "uint256"
    }
  },
  Winner: {
    keySchema: {
      match: "uint256"
    },
    valueSchema: {
      player: "address"
    }
  },
  Terrain: {
    keySchema: {
      x: "int32",
      y: "int32"
    },
    valueSchema: {
      type: "uint8"
    }
  }
}

After

const tables = {
  Position: {
    schema: {
      player: "address",
      x: "int32",
      y: "int32"
    },
    key: ['player']
  },
  Health: {
    schema: {
      player: "address",
      health: "uint256"
    },
    key: ['player']
  },
  Inventory: {
    schema: {
      player: "address",
      item: "uint8",
      amount: "uint32"
    },
    key: ['player', 'item']
  },
  Score: {
    schema: {
      player: "address",
      match: "uint256",
      score: "uint256"
    },
    key: ['player', 'match']
  },
  Winner: {
    schema: {
      match: "uint256",
      player: "address"
    },
    key: ['item']
  },
  Terrain: {
    schema: {
      x: "int32",
      y: "int32",
      type: "uint8"
    },
    key: ['x', 'y']
  }
}

[holic]

we're doin it