In content library transformer handle the cases where the old selected modules are no longer valid and update the user's set of selected modules.

CCX courses usage keys are of type CCXBlockUsageLocator, not
BlockUsageLocator like everything else.

Before this commit, BlockStructures were being cached with one
entry for the top level data (structure, course-wide transform
data), and an entry for each block's data. There can be thousands
of blocks in a course. While this makes it so that you can grab
a small subset of blocks without incurring much overhead,
splitting the block information means that the overall size of the
data stored for generating course-level views increases drastically,
since compression is less efficient.

Making this change yields about a 7X decrease in serialized data
size.

Small, localized changes:

* Shifts some of the HtmlModule logic around, moving student view
  handler logic to HtmlBlock (a replacement for HtmlFields, as we move
  just a little closer to making it a real XBlock).

* Removes has_multi_device_support() from capa, so that we don't have
  to mess around with student state. To determine whether all response
  types in that particular problem support mobile, we make use of
  self.problem_types (originally built for content library filtering).

The bigger changes are to handler URL generation:

* The LMS now also monkey-patches
  xmodule.x_module.descriptor_global_handler_url and
  xmodule.x_module.descriptor_global_local_resource_url so that we can
  get LMS XBlock URLs from the DescriptorSystem. That functionality is
  needed in the block transforms collect() phase for certain XModules
  like Video. For instance, say we want to generate the transcripts
  URLs. The collect phase is run asynchronously, without a user context.

* The URL handler monkey-patching is now done in the startup.py files
  for LMS and Studio. Studio used to do this in the import of
  cms/djangoapps/contentstore/views/item.py. This was mostly just
  because it seemed like a sane and consistent place to put it.

* LmsHandlerUrls was removed, its handler_url and local_resource_url
  methods were moved to be top level functions. The only reason that
  class existed seems to be to give a place to store course_id state,
  and that can now be derived from the block location.

* To avoid the Module -> Descriptor ProxyAttribute magic that we do
  (which explodes with an UndefinedContext error because there is no
  user involved), when examining the block's handler method in
  handler_url, I made a few changes:

** Check the .__class__ to see if the handler was defined, instead of the
   block itself.

** The above required me to relax the check for _is_xblock_handler on the
   function, since that will no longer be defined.

90% of this goes away when we kill XModules and do the refactoring we've
wanted to do for a while.