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.