Instead of using an intent struct, we use a efficient custom encoding instead. This reduces gas by ~12k for single intents and ~10k for intents in a batch

Gas savings come from:

1. Smaller intent size (by ~5-10 words). This results in less memory usage, less memory expansion, and less intrinsic calldata cost paid
2. Removing custom offset checks LibBytes.checkInCalldata (~2-3k gas alone)
3. Not requiring just-in-time checks on struct offsets when accessing any struct field (solc adds this under the hood)
4. Optimizing the args for _pay to only take in what we currently use today instead of the full intent
5. Removing fields from the EIP-712 digest - 2 less keccak operations

The new format is abi.encodePacked, but with some nuances:

1. All static fields go before all dynamic fields, so all static fields have known offsets
2. The static fields that go into the EIP712 digest are ordered continuously
3. The static fields that are in the EIP712 digest are padded to 32 bytes, then with the previous property this allows us to do a single calldatacopy for digest calculations
   (The relayer has the freedom to use dirty bytes on these fields, but then the digest would compute to something else and this would fail verification, so there's no incentive to do so)
4. Dynamic fields are prefixed with uint256 field.length to allow us to use them as a bytes calldata directly
5. We order the dynamic fields in the order that they will be used in the orchestrator flow

We rely on the helper function _getNextBytes(ptr) for efficient traversal through the dynamic fields. The helper function assumes that the pointer already points to the start of a dynamic byte range. It parses that out, then updates the CalldataPointer in memory to point to the start of the next dynamic byte range