Add variable `priority` to struct `process`

The new `priority` variable can be used by the scheduler when choosing which
thread should run next. `priority` is an enumerator that can have
values of LOW, NORMAL or HIGH.

Also make default process priority NORMAL
Add documentation for xrndbuff.h

Add documentation which gives a conceptual framework for thinking about the
functions declared in `xrndbuff.h`.
Remove "next" variable from round buffer lib

Do not use both a "next" and "current" variable in xroundbuffer.c. Instead, just
use "current".
Clean up xrndbuff.c
Remove function set_current()

Also remove all references to function set_current()
Rewrite Scheduler interrupt function

Scheduler is signficantly simpler to read through
Remove bool `first_time` from Scheduler function

Remove the check to see if this is the first time the scheduler has run.
Instead, rely on the xroundbuffer.h functions such as `get_next()` and some
improved logic to find which thread should run next.

Also improve a debugging message.
Update roundbuffer indexing functions

Delete `set_idle()` and add `set_current()`. The former was a hardcoded hack,
and the latter is a bit more flexible.

The ultimate aim here is to change the roundbuffer functions so that "Only
`add_process()` and `set_current()` affect the index." This will allow
`Schedule()` to more easily walk through the roundbuffer without worrying about
accidentally affecting the index.
Add function `_process_exists()`

Addition of function removes duplicate code. Function checks to see whether a
given `processID` is sane.
Make `get_next()` accept a parameter

Make `get_next()` accept a `processID` as a parameter. `get_next()` now searches
for the next process relative to the given processID instead of the current
ringuffer index position.

Importantly, the only functionw which now affect the ringbuffer index are
`add_process()` and `set_current()`. The codebase now agrees with the
documentation laid out in xrndbuffer.h.
Add member "score" to process struct

Member "score" and "priority" can together be used to make modestly nuanced
decisions about scheduling. The end goal is this:

    1. Each time `Schedule()` is called, bump the score of each process. The
       more the score is bumped.
    2. Select the process with the highest score, reset the score to 0, and run
       it. If multiple processes have the same score, run the first process
       after the currently selected process.
Schedule processes using a scoring system

See previous commit message for concept