tornado: Rewrite Django integration to duplicate less code.

Since essentially the first use of Tornado in Zulip, we've been
maintaining our Tornado+Django system, AsyncDjangoHandler, with
several hundred lines of Django code copied into it.

The goal for that code was simple: We wanted a way to use our Django
middleware (for code sharing reasons) inside a Tornado process (since
we wanted to use Tornado for our async events system).

As part of the Django 2.2.x upgrade, I looked at upgrading this
implementation to be based off modern Django, and it's definitely
possible to do that:
* Continue forking load_middleware to save response middleware.
* Continue manually running the Django response middleware.
* Continue working out a hack involving copying all of _get_response
  to change a couple lines allowing us our Tornado code to not
  actually return the Django HttpResponse so we can long-poll.  The
  previous hack of returning None stopped being viable with the Django 2.2
  MiddlewareMixin.__call__ implementation.

But I decided to take this opportunity to look at trying to avoid
copying material Django code, and there is a way to do it:

* Replace RespondAsynchronously with a response.asynchronous attribute
  on the HttpResponse; this allows Django to run its normal plumbing
  happily in a way that should be stable over time, and then we
  proceed to discard the response inside the Tornado `get()` method to
  implement long-polling.  (Better yet might be raising an
  exception?).  This lets us eliminate maintaining a patched copy of
  _get_response.

* Removing the @asynchronous decorator, which didn't add anything now
  that we only have one API endpoint backend (with two frontend call
  points) that could call into this.  Combined with the last bullet,
  this lets us remove a significant hack from our
  never_cache_responses function.

* Calling the normal Django `get_response` method from zulip_finish
  after creating a duplicate request to process, rather than writing
  totally custom code to do that.  This lets us eliminate maintaining
  a patched copy of Django's load_middleware.

* Adding detailed comments explaining how this is supposed to work,
  what problems we encounter, and how we solve various problems, which
  is critical to being able to modify this code in the future.

A key advantage of these changes is that the exact same code should
work on Django 1.11, Django 2.2, and Django 3.x, because we're no
longer copying large blocks of core Django code and thus should be
much less vulnerable to refactors.

There may be a modest performance downside, in that we now run both
request and response middleware twice when longpolling (once for the
request we discard).  We may be able to avoid the expensive part of
it, Zulip's own request/response middleware, with a bit of additional
custom code to save work for requests where we're planning to discard
the response.  Profiling will be important to understanding what's
worth doing here.

zerver/middleware.py

@@ -240,11 +240,27 @@ class LogRequests(MiddlewareMixin):
     # method here too
     def process_request(self, request: HttpRequest) -> None:
         maybe_tracemalloc_listen()
+
+        if hasattr(request, "_log_data"):
+            # Sanity check to ensure this is being called from the
+            # Tornado code path that returns responses asynchronously.
+            assert getattr(request, "saved_response", False)
+
+            # Avoid re-initializing request._log_data if it's already there.
+            return
+
         request._log_data = dict()
         record_request_start_data(request._log_data)
 
     def process_view(self, request: HttpRequest, view_func: ViewFuncT,
                      args: List[str], kwargs: Dict[str, Any]) -> None:
+        if hasattr(request, "saved_response"):
+            # The below logging adjustments are unnecessary (because
+            # we've already imported everything) and incorrect
+            # (because they'll overwrite data from pre-long-poll
+            # request processing) when returning a saved response.
+            return
+
         # process_request was already run; we save the initialization
         # time (i.e. the time between receiving the request and
         # figuring out which view function to call, which is primarily
@@ -256,6 +272,12 @@ class LogRequests(MiddlewareMixin):
 
     def process_response(self, request: HttpRequest,
                          response: StreamingHttpResponse) -> StreamingHttpResponse:
+        if getattr(response, "asynchronous", False):
+            # This special Tornado "asynchronous" response is
+            # discarded after going through this code path as Tornado
+            # intends to block, so we stop here to avoid unnecessary work.
+            return response
+
         # The reverse proxy might have sent us the real external IP
         remote_ip = request.META.get('HTTP_X_REAL_IP')
         if remote_ip is None:
@@ -371,6 +393,12 @@ class FlushDisplayRecipientCache(MiddlewareMixin):
 
 class SessionHostDomainMiddleware(SessionMiddleware):
     def process_response(self, request: HttpRequest, response: HttpResponse) -> HttpResponse:
+        if getattr(response, "asynchronous", False):
+            # This special Tornado "asynchronous" response is
+            # discarded after going through this code path as Tornado
+            # intends to block, so we stop here to avoid unnecessary work.
+            return response
+
         try:
             request.get_host()
         except DisallowedHost: