There are still some bugs I need to work out.

This requires listening for the `aio-cancel` signal in an `aio-listen`
callback and calling `request-abort`.

Upstream:
https://github.com/telotortium/emacs-aio-iter2/blob/5b0a9f81ed5bddc60f252b4f46924887190d91af/aio-iter2.el

Otherwise, MELPA will fail to load this file. I'm done with development
of aio-iter2, I'm pretty sure.

`org-gcal-test--post-at-point-aio-basic` mostly works as intended, except
that the `let` bindings don't function as intended - not sure why.

It appears that this keyword doesn't work for this.
I don't know if there's a way to make it work, or I'll
just need to write a wrapper interactive function around the
AIO functions.

Will tag and bump to 0.5.0 after aio branch is merged.

Follow [Multi-file
Packages](https://www.gnu.org/software/emacs/manual/html_node/elisp/Multi_002dfile-Packages.html)
in Emacs Lisp Manual, inspired by
[magit-pkg.el](https://github.com/magit/magit/blob/b32521d5432b5fbc33a2e47b72f2258bf98cb8b4/lisp/magit-pkg.el).

Needed because Cask wasn't picking up the `iter2` dependency of
`aio-iter2` - this is an indirect dependency of `org-gcal.el`, but
wasn't included in the `Package-Requires` line before. Since we use
multiple Emacs Lisp files, it's best to acknowledge that explicitly.

This won't be directly used, but I'd like to break out this file
into a separate package someday.

Figured out right way to do it.

- Allow testing only a subset of tests using `TEST_PATTERN`.
- It appears some tests occasionally fail if run all in the same Emacs,
  but work if they are run separately. So, if I find failed tests, I
  rerun each failing test individually to see which ones actually fail.

Useful for writing test servers to test code using a real HTTP server
instead of mocks.

Will be needed for main code and tests.

Now it seems like this work interactively, and working on tests.

See doublep/iter2#3 for context.

Ensure package remains clean with respect to checkdoc.

Work around aki2o/log4e#9.

Improves the speed of modifying buffers when many updates are being
done.