Removed the control queues from distributaries, and distributaries no longer
support out-of-kernel loads.
This patch introduces some nice RAII classes for easing asynchronous development
and ensuring that memory is freed after use.

* Implemented class cleanupC:
  * Can be used to ensure that local variables which point to memory which must
    be freed will be freed.
  * Forms the base for the asynchronous abstraction, asyncResponseC.
* Implemented class asyncResponseC:
  * Can be used to automatically send an async response to a target thread
    using C++ RAII, before a particular function exits.
* Unified a bunch of message structures from floodplainn that were formerly
  part of the ZUDI-Index server protocol.
* Now that we have ZAsyncStream, we no longer need MSGSTREAM_SUBSYSTEM_REQ?.
* Implemented connectionless listen() for zasyncStreamC.

* Cleaned up a bunch of testing code from __korientation.
* Tested connectionless ZAsyncStreamC::listen().
* Renamed some of the files to do with the ZUDI-Index server.
* All ERROR_* constants are now cast to (error_t) in code.
This patch rescinds the pointer-managing RAII class from last patch, but
posits instead three RAII classes which behave very similarly to
std::unique_ptr.

The first is for heap allocations, the second (loosePagePtrC) is for loose
pages allocated via vaddrSpaceStreamC::getPages(), with support for fully
retiring such pages, even to the extent of unmapping them, and the third is a
manager for memory pages allocated with memoryStreamC::memAlloc().

Furthermore, the kernel has now got past the zudi index server initialization
hurdle.

* zasyncResponseC:
  * Moved class definition into messageStream.h.
  * Moved implementation into messageStream.cpp.
* cleanupC: Deleted.
* operator new[]: In this patch I fix some grievous errors in the way I'd
  implemented new[] and delete[]. Basically, I didn't properly understand them
  before, and as a result of that, I'd had some terrible code in the kernel.
* Implemented a simple solution to the async-continuation context problem for
  async syscalls: we don't error check the small allocations; they will probably
  never fail anyway, and this allows us to allocate them quickly using a single
  function call.
* floodplainn:
  * zudiIndexMsgS was not properly upcasting back to itself when cast down to
    void * first; had to make the zudiIndexMsgS a member instead of a baseclass.
  * New member variable: zudiIndexServerTid: Used to track the current thread
    ID of the ZUDI Index server.
Kernel now executes detectDriverReq() fully.

* __korientation reached up to main3 now.
* zudiIndexParserC: Now some of the overture header get() functions take a
  zudi::headerS pointer.
* Integrated the newSyscallback() function into the kernel.

TODO: Add a "total count" of all the devices in the device header index. Can
put this for example, in the index header.
Fixed a memleak in detectDriverReq().
Kernel now almost gets to where it was in loadDriverReq. Next thing to do is
get driver metadata loading into the kernel done.

* memory.h:
  * Increased the number of usages of heapPtrC<>.
  * Made constructors for ptrC<> and its derivatives all explicit.
Kernel's loadDriverReq() now has the structure required to properly initialize
a driver object for use in instantiation.

* libzudiIndexParser: Implemented a whole lot of other functions that have to do
  with parsing various other types of statements, including bind operations.
* device.h: Began laying down the groundwork for the filling in of the driver
  objects by loadDriverReq().
* Minor "optimization", though not really, in realloc().
* Finally implemented strcat8().
* Created constructors for all the subclasses of fplainn::driverC.
* Wrote implementations for fplainn::driverC::preallocate*().
* detectDriverReq() now fills in more information about the device, such as
  its long name, the shortname of its driver, its vendor, and contact info.
* Proper constructor for fplainn::driverC.
Moved some metadata structure members around to reduce data duplication, and
improved state machine consistency on classes in fplainn::* namespace.
Added a safety check to the request handling loop in ZUDI Index server.
Minor touchups, and implemented a dump() method for fplainn::driverC.
Furthermore, now loadDriverReq() properly fills in strings in driver objects
such as name, supplier and contact, as well as adds the driver object to the
loaded driver list.
Kernel now successfully spawns driver processes. They don't run, or enter any
useful code sequence, but they are spawned, and they execute.

* ptrC: addressOf() implemented.
* New floodplainn primitive: findDriver().
* Polished up processTribC::spawnDriver().
* zudiIndexServer::newDeviceInd() now works all the way up to completion.