Xoto3

- Switches `BatchGetItem`'s threadpool to `concurrent.futures.ThreadPoolExecutor`
to work in AWS Lambda environments running Python 3.8+
- Adds `scripts/create_integration_test_table.py`; creates a DynamoDB table used
for running integration tests

- Fix xoto3.lam.finalize for Python > 3.7

- `write_item` single item write helper for the `write_versioned`
higher level DynamoDB transaction API. Suitable for any form of
transactional write to a single item (creation/update/deletion).

Fixes to `versioned_transact_write_items`:

1. `presume` will now apply the standard dynamodb_prewrite transform,
so that we don't get into situations where tuples aren't equal to
lists, or floats aren't equal to Decimals, for instance. Anything
presumed should look like an actual DynamoDB value, in other
words. This oversight was leading to certain situations where
presume was being used causing a superfluous write to the table.
2. The returned transaction will always include any items inserted
into the transaction by `presume`, even if no effects were
applied. This only occurred when a single item was presumed for the
whole transaction and no changes were made to it, but it makes the
API slightly easier to work with.

Changes to `versioned_transact_write_items`:

1. Any write to an item that leaves it in its pre-existing state
(`==`) will perform only a ConditionCheck and not an actual
Put/Delete on that item. This avoids having incrementing
`item_version` when nothing was actually changed.
2. Single-item `versioned_transact_write_items` where the item is
unchanged (`==`) performs no ConditionCheck and no spurious
write. If you're not operating on multiple items, then there is no
meaningful 'transactionality' to knowing whether the item was
changed _after_ your transaction started, because transactions
can't assert anything about the future - only about a conjunction
between multiple items at a point in time.

`StackContext` and `OnCallDefault` utilities for providing new ways of
injecting keyword arguments across a call stack without polluting all
your function signatures in between.