Reduce database queries on slow pages

* Cache field permissions
* Use `select_related` in key places to prefetch related objects
* When a user is viewing their own "My Account" page, don't filter edits by field visibility

Before/after SQL query counts:
541 / 25 - My Account 
162 / 52 - Plot Detail

The main feature of this work is the `InstanceAdjuncts` cache. For each instance, cache "adjunct" objects -- frequently-accessed objects which change rarely -- by storing them in local memory. Track cache validity via a database timestamp on each instance (`instance.adjunct_timestamp`). Check the timestamp before returning any object from the cache; if it's stale invalidate all adjunct objects for the instance.

When an adjunct object is modified (saved to the db or deleted), invalidate the appropriate instance's cache and update its timestamp. The timestamp update will cause the change to propagate to any other servers.

UDF definitions are now cached in `InstanceAdjuncts` instead of their own cache, with the benefit that changes are propagated to all servers.
Does the outer part of the query do a join on instance, for what appears to be no reason? If so, it's because of `instance__in`.

I think it's repeating work to execute the subquery again. Earlier in this code block, there's a forloop executed on instances, which means the objects will have been pulled into python memory from the same query. So I think grabbing the ids in a list comprehension should be done without a query, and very fast in python.

However, the subquery, repeated or not, is of little concern. The main point was to produce a structure that can readily be fed to `instance_id__in`, rather than `instance__in`.