Save timezone utc date time

Opening this for review as a solution to what was discussed at https://github.com/dimagi/commcare-hq/pull/4386#discussion_r18218758. (Notice I'm PRing into save-timezone.)

This solution introduces a new `datetime` sublcass, `UTCDateTime` that acts like a tz-naive datetime (what we use everywhere) but also keeps track of its "original offset". Compare to a tz-aware datetime:

The current time EST in as a timezone-aware `datetime`:
```python
datetime.datetime(2014, 10, 8, 15, 30, 20, 239874, pytz.FixedOffset(-4 * 60))
```
The same time as a `UTCDateTime`:
```python
UTCDateTime(2014, 10, 8, 19, 30, 20, 239874, original_offset='-04:00')
```

Notes that in the UTCDateTime example, the numbers for hours, minutes, etc. are the values for the UTC time, but the offset is preserved as `original_offset`, to mean "this UTC date was gathered from this timezone".

This lets us treat these objects exactly like we treat the timezone-naive `datetime`s we use everywhere to mean UTC, but without throwing away that information.

`UTCDateTimeProperty` then uses these new `UTCDateTime`s exclusively. It reads in any ISO 8601 datetime, but strictly writes out ISO 8601 unicode datetimes, with microseconds (and the 'Z' ending), followed by a space and the UTC offset string (e.g. '-04:00').

Todo:
- [x] This is obvious, but enable it to read in its own output format (which is not ISO 8601). (I just realized I hadn't done this.)
- [ ] If we like this, fix all the tests to include this utc offset string where necessary

You'll also notice I added a `corehq.ext.unittest` file that contains something I've wanted to be part of our testing library for a long time: a helper for creating "corpus tests" that just compare a bunch of pre-defined inputs and outputs to the real outputs of a function. You can see how these are used with the tests I just added.
But aren't those... _not_ equal?

This touches on an annoying discrepancy between == and the other comparators currently (and the equivalent in `datetime.datetime`).

Currently `UTCDateTime.__eq__` checks for exact equality of all fields, including `original_offset`, but `<`, `>`, `<=`, and `>=` ignore `original_offset` which seems correct. `datetime.datetime.__eq__` just makes sure that the two datetimes refer to the same point in time, so two datetimes with different timezones can actually be equal.

Not sure what I should do about that. Perhaps the best thing is to go with the build-in equal and add an "exact_equals" or something for also comparing the offset. (It's just annoying because all these tests rely on `assertEqual` in testing their output. I could have `Returns` take in an equality function (or a transformation to apply to both before comparing, since in this case calling `repr` on both would be equivalent to exact equals). What do you think?