Intermediate commit before some huge changes.
Should be done with all the classes now
Replaced most structs
Went through structs with a finer-toothed comb.
Fixed up CpuStream and did more fine-tuning.
Pretty beautiful patch, if you ask me, or really anyone else who has worked with
this source (nobody else). I've managed to create a really nice continuation
and callback framework that makes callbacks and async very clean, though
somewhat taciturn.

Callback objects can be used as the "privateData" for syscalls. These Callback
objects have polymorphic methods that will correctly call the callback function
they contain. This enables us to use completely callback-agnostic event loops,
and get type-safe callbacks for all async calls.

The only real drawback is that this new approach mandates memory allocation for
every async call. We cannot reasonably find a way to hardcode the Callback class
instances within MessageStream::sHeader.

I was pleasantly surprised to find that the kernel executed to completion
almost immediately, and without a hitch. The new abstraction is *very* clean in
that sense -- it was integrated very quickly and very painlessly.

This new callback framework removes the need for MessageStream::sIterator.
Also makes message passing (in theory) as quick as moving a pointer around.

I hope for the next 2-3 patches to introduce the cleanup for the per-cpu thread
fiasco.

* Callbacks:
  * Added callback.h:
    * class Callback, a polymorphic base class (abstract) with an operator()
      that can be invoked to execute the callback function contained inside of
      the object.
    * __kCallback: Extrapolated class for very "standard" callbacks which may
      be common throughout the kernel.
  * Integrated Callback throughout the kernel except in maybe ZUI Server.
* Namespacing:
  * Namespaced all the monstrous code inside of __klibzbzcore.
  * Cleaned up all of that code as a result; it is much cleaner now, and far
    more easily readable and navigable. And that with a grain of salt, too.
* New stub for taskTrib.kill(). Wraps around taskTrib.dormant.
Integrated the Callback framework into ZUDI Index Server. It instantly cleaned
up the message loop by removing about 60% of the code in it.

* Added some notes to todo.txt about my feelings and conclusions over the
  need to restructure per-cpu-threads.
Minor stylistic changes.
First step toward removing per-cpu threads. Replacing them with power threads.
Each CPU now has an embedded thread that is its own and has the ID of its
owning CPU. Removed former methods like getTaskContext(), etc.

Restructured the inheritance chain for Task, Thread and TaskContext. Thread
now directly inherits from Task and TaskContext. Task and TaskContext cannot
be immediately instantiated.

I am a bit taken aback (actually, I'm completely shocked) that the kernel ran
to completion on the first try after I got it building again. Naturally, I am
currently in a state of high alert as a result of that...
Introduced changes to the kernel's boot sequence in line with my current vision
for a clean bootup. The kernel is being made into a much more microkernel-esque
form factor, and soon it will be highly message passing, and far more
organized.

We now have Memory Management from very early on in the boot sequence. This is
quickly followed by process spawning and threading, and soon by scheduling.

Effectively, this causes the kernel to behave like a microkernel. We will
strongly postpone the initialization of IRQs, since our original reason for
initializing IRQs so early was to facilitate the early petting of watchdog
devices. Instead, we will require that chipsets with watchdog devices include
some kind of mechanism for ensuring that they pet their own watchdog device in a
chipset-specific manner, which the kernel is not required to know about.

This enables us to offload all chipset/device related setup to much later on in
the boot sequence.

This patch also sees the end of the __korientation and __kcpuPowerOn sequences
as identifiable thread entities, and demotes them to execution sequences only.
We've removed completely all ground for per-CPU threads to stand on, in their
/former/ appearance. They are now quite literally addressable per-CPU thread
objects. Each CPU has its own pCPU thread. Over the next few patches, we should
have stabilized this new per-CPU threading format, and thereby stabilized the
entire kernel source.

I will split the changes in this patch into 3 main sections.

Per-CPU Threads:
CpuStream:
  * Renamed CpuStream::baseInit() to CpuStream::initializeBaseState().
  * Split CpuStream::initializeBaseState() into base state initialization
  (GDT + CpuStream pointer load into DR0), and exception initialization.
__korientation and __kcpuPowerOn:
  * __korientation has generally been removed.
  * __korientationPowerStack has been offloaded into a global symbol and we
    can now retrieve it through the global.
  * New abstraction for the BSP CPU:
    We need at various times to know whether or not it is the first time the
    BSP CPU is being detected or initialized. Previously the logic for
    determining this was mediocre and weak. Now we have introduced a proper
    set of states for specifying exactly which iteration of initialization
    or hotplug the BSP CPU is in.
    * Introduced FIRSTPLUG, HOTPLUG and NOTBSP state values.
    * Introduced matching state query methods into the CpuStream class.
    * As a result, removed all flags which previously indicated BSP status:
      (CPUSTREAM_FLAGS_BSP, and so on).
    * All CpuStream member objects and member classes take a BSP plug status
      variable in their constructors. Keep in mind that we can probably
      abstract this into a global. It is unlikely to change oft enough to require
      locking either. Or even be reference enough for locking on it to be a
      performance hindrance.
  * Every CPU now has its own PowerThread, and its own PowerStack.
* MessageStream is now a member of Thread and not of _TaskContext.

Kernel boot sequence:
  * DebugPipe __kdebug instance is initialized much earlier now, so we have
    printing very early on in the boot sequence.

General:
  * New method to determine whether or not a CPU is the BSP CPU:
    CpuStream::isBspCpu().
  * Class Stream is now a template and it accepts a parameter which determines
    the type of its member "parent" pointer.
  * We can later make this derive from a StreamBase class, which can be used
    for polymorphism, in whatever form we implement such polymorphism later on
    in the kernel.
Smoothed out a lot of wrinkles from the last patch; still some way to go. I hope
that we can seamlessly get to the driver spawning soon so we can write the
FloodplainnStream class, and then move into the really fun stuff in UDI.

A whole lot of re-ordering of the kernel boot sequence has occured.

Removed the per-CPU BSP Plug Type introduced last patch; this information will
be global now.

* Right now the kernel is spawning all threads with local IRQs disabled.
* Added __attribute__((packed)) to RegisterContext.
* cpu_t is now unsigned.

* __korientation:
  * Fixed a bug where we were loading the wrong address for the
    BSP CPU's power stack, and thereby causing trampling of the .rodata section.
  * __korientationInit no longer exists; we now fully salvage the boot thread.
    (The dream!). __korientationEntry calls directly into __korientationMain
    which moves directly into its message loop.

* Cpu:
  * Removed CpuTrib::initializeBspCpuStream().
    ^ Replaced with CpuTrib::loadBspInformation().
  * Kernel now loads the BSP CPU's ACPI ID in loadBspInformation().
  * Added a "requery" feature to zkcmCore.cpuDetection.getBspId().
  * Threads now take an optional CpuStream pointer in their constructor,
    enabling us to give power threads a pointer to their parent CPU.
  * Much better BSP CPU identification code.
  * cpu_t is now unsigned.

* Lib:
  * Added realloc() to the heap.
  * Removed asyncContextCache.
  * Added strstr8(). Grossly inefficient; gloriously functional.

* Sched/Threading:
  * SPAWNTHREAD_FLAGS_POWER_THREAD: introduced to reduce code duplication for
    initializing threads.
  * TaskStreams now call spawnThread() on their power threads in
    cooperativeBind().
  * Much better power thread identification code.
Kernel now executes to where we had been previously, within the driverMain
and deviceMain sequences.

Fixed one or two bugs along the way. Next patch should see me calling
CpuStream::bind() in the __korientationMain() path, and the beginnings of the
FloodplainnStream class.

Following that, we should be able to do our metalanguage connect() operations,
and from there, we can finish up UDI.

* Debugging:
  * New test function int testFunction(...);
    ^ Returns 0 always.
    ^ Takes any number of untyped arguments.
    ^ Useful for forcing the compiler not to ignore operations since it does not
      know the side-effects of this function call.
  * Moved getEsp() into the debug:: namespace, under the new name:
    getStackPointer().
  * Moved getCr3() into the debug:: namespace, under the new name:
    getVaddrSpacePointer().

* We now call chipsetEventNotification on the IBM-PC terminal via ZKCM Core,
  very early to get the VGA buffer remapped asap.
* IrqControl mod's chipsetEventNotification doesn't any longer call i8259aPic's
  chipsetEventNotification.
* Fixed a bug in PrioQueue, where we were calling delete() on an object
  allocated from a SLAM cache.

* Reduced the number of spins for spinlock detection from 0xF00000 to 10,000.
Got rid of some obsolete code and now the CpuStream::bind() no longer enables local IRQs.
Removed all the old per-cpu TaskTrib scheduler functions.
This patch is truly a very diverse patch in terms of focus.

I've added and improved iterators in some of the kernel's list classes. The ZUI
server thread is now a thread and nothing more; it is no longer a distributary
and the remnants of that form of it will be removed over time. We no longer
allow processes to direct their syscall responses to other threads, or other
processes. This feature has been removed from those APIs which had already
implemented it.

Improved the separation of function between the components of Floodplainn. Now
we have 3 logically distinct components: Floodplainn, ZUI and ZUDI. ZUDI will
soon be renamed to ZUE.

New driver: zrootdev. This is actually not a proper UDI driver, but an
embodiment of the kernel within a driver. The root device in the kernel device
tree is now "@f/by-id" itself.

* __kclasses:
  * HardwareIdList:
    * Improved Iterator.
      ^ It now works such that begin() returns an iterator that references the
        first valid object, and the "cursor" member has the correct index filled
        in. Previously, the cursor member would have the index of the next
        member, Y, while holding the value of a member, X.
      ^ Added all necessary operators to Iterator.
    * Renamed getLoopItem() to getNextItem().
    * Removed prepareForLoop(), and made getNextItem() private.
* API & functionality:
  * Kernel no longer supports response redirection for syscalls.
    ^ As a result, determineTargetThreadId() now always returns the ID of the
      target thread as passed to it.
* Added udi_bridge and udi_physio related headers to the kernel tree.
* UDI:
  * New driver: zrootdev.
  * Kernel root device is now @f/by-id.
  * Did a whole lot of tedious namespacing of the Floodplainn, ZUI and ZUDI
    components.
  * Now the default action for new device indication is set by default in a
    global variable. No longer need to syscall to tell it what to do.
  * Each new component also has its own MessageStream queue.
* Prototyped FloodplainnStream.
* Renamed floodplainn_zuiServer_*End.cpp to zui*End.cpp.
* Added new kernel-nomenclature device classes.

* Kernel now enumerates @f/by-id in fplainn::Zui::initialize().
  ^ We now allow getDevice() to return handles to @f/by-id.

* Fixed a minor bug in fvfs::Currentt::getPath(), where stripping away @f from
  a path after stripping away slashes may not have worked.
Completed the set of changes required to facilitate the execution of
instantiateDeviceReq(). This leaves us with spawned drivers and instantiated
devices, but no metalanguage connections.

We can connect devices together and connect internal-bind regions, and as of
this patch we can also allow drivers to spawn arbitrary channels of their own.
We have regions, channels, and the underlying infrastructure needed for
message passing.

The next step is going to be writing the code to actually connect processes to
drivers, and the code for sending messages along channels. Following that, we'll
have everything needed to begin moving into UDI in full force, other than the
udi_enumerate_req code.

General changes around the tree to facilitate the features we've introduced in
this patch:

* ::Thread now holds a pointer to an fplainn::DeviceInstance::sRegion.
  ^ This enables us to quickly and painlessly obtain a pointer to our region
    information from within a device's region thread.
* fplainn::DeviceInstance::sRegion now has a pointer to its parent
  DeviceInstance object, allowing us to quickly move from a region object
  upwards to its device instance details.
* fplainn::DeviceInstance::sChannel and
  fplainn::DeviceInstance::sIncompleteChannel have been similarly augmented to
  provide similar convenience pointers.

* ZUDI:
  * Fixed a bug in __klibzbzcore::driver::__kcontrol::handler where we weren't
    cloning the original kernel message correctly.
  * Revised spawnChannel().
  * implemented udi_channel_spawn().

* Miscellaneous changes to fplainn::*:
  * Device:
    * Added indexedGetParentTag() to allow userspace to cycle through the
      parents of a device.
  * DeviceInstance:
    * Added setThreadRegionPointer() to allow libzbzcore to direct the kernel
      to set the region pointer for a thread when it has spawned the region
      threads for a device.
    * Replaced all tid metadata in the hierarchy with direct thread pointers or
      region pointers.
    * Did the same for all channel spawning functions.
    * Fleshed out IncompleteChannel and the sEndpoint structs for both Channel
      and IncompleteChannel.
    * Now the channel list is a ::List instead of a disgusting array.