Document the opcode processor and how it fits into the engine

This patch adds documentation describing the LNVL.Opcode.Processor
table and how LNVL uses it.  This table does not exist though.  The
documentation comes first to serve as a design guide for the
implementation to follow.
Define and document the LNVL.Opcode.Processor table
Create processor functions for existing opcodes

This patch moves all of the opcode modification code out of the
Scene:createOpcodeFromContent() method and refactors it into specific
entries in the LNVL.Opcode.Processor table.  This is not only better
organization—it keeps more of the opcode logic in the ‘opcode.lua’
file—but it also makes it possible to implement new opcodes without
having to modify any code inside of Scene:createOpcodeFromContent().
Clarify and correct some comments in Scene:createOpcodeFromContent()
Merge branch 'refactor-opcode-generation'

* refactor-opcode-generation:
  Clarify and correct some comments in Scene:createOpcodeFromContent()
  Create processor functions for existing opcodes
  Define and document the LNVL.Opcode.Processor table
  Document the opcode processor and how it fits into the engine
Correct the paths to documentation in two source file headers

Two files direct programmers to HTML documentation.  However, the HTML
format of the documentation is not part of the repository.  We
generate those HTML files using Pandoc and Tup.  If the programmer
does not have those two programs then those paths will lead him
nowhere.  Instead we should reference the documentation format which
is actually part of the repository, and which is readable as-is.
Improve the whitespace and formatting of the code

This patch contains no logic changes.  It only modifies the whitespace
and some curly-brace placement to help improve readability.
Fix a crash when building a scene’s opcode table

The method Scene:createOpcodeFromContent() may return nil.  That
causes a problem because we call it directly as an argument to
table.insert() so when it returns nil we end up with the problem of
calling table.insert() with not enough arguments.  We need to separate
the call to createOpcodeFromContent() and test its value so that we do
not waste space insert nil values into the opcodes table.
Link to the original source for LNVL.Debug.tableToString()
Add a debugging function for dumping out scene opcodes

This is a useful utility that we can use to ensure that a scene
generates the correct number and sequence of opcodes we expect from a
given input script.
Test for a nil ‘arguments’ property in LNVL.Opcode.__tostring()

Not every opcode will have an arguments table.  Currently ‘no-op’ is
the only opcode that falls into this category, but others may follow.
When converting opcodes to strings we assume that table always exists
but this causes a crash when trying to convert ‘no-op’ to a string.
This patch corrects the logic of string conversion for opcodes by
adding a test for the existence of that table, and it updates the
documentation for opcodes to mention that we cannot rely on them to
always have an arguments table.
Improve the output format of LNVL.Opcode.__tostring()

This patch condenses the amount of whitespace we use, particularly in
the case of opcodes which have a nil ‘arguments’ property.  This will
make the output of LNVL.Debug.printSceneOpcodes() more readable.
Add LNVL.Settings.DebugModeEnabled

We will use this boolean setting throughout the code to decide whether
or not to generate debugging output and data.  The default value is
true because that is what we will want up until the point we’re ready
to release a finished visual novel.

This patch also changes the order we load the LNVL modules so that
LNVL.Settings comes first.  We need to do this so that LNVL.Debug will
have access to the setting.
Show opcodes for every scene when using debug mode
Document the debugging utilities related to scene opcodes
Merge branch 'global-debug-setting' into better-character-positioning

* global-debug-setting:
  Document the debugging utilities related to scene opcodes
  Show opcodes for every scene when using debug mode
  Add LNVL.Settings.DebugModeEnabled
Clarify why LNVL.Character:isAt() returns a ‘no-op’ opcode
Fix bug preventing inclusion of ‘draw-character’ opcodes in scenes

Commit 124f3859 (‘Create processor functions for existing opcodes’)
accidentally removes the final return statement from the code for the
‘draw-character’ opcode.  Because of this the opcode never appears in
any scene, and thus LNVL never draws characters to the screen.  This
patch corrects that accidental deletion.
Clarify that opcode processor functions return opcodes

This makes it clear that not only do opcode processor functions return
opcodes, it is a requirement that they do so.
Test for opcode and instruction implementations in debug mode

LNVL keeps a list of opcode and instruction names that it recognizes
as valid.  If we add a new entry to that list but fail to actually
write the necessary code to implement the opcode/instruction then it
can cause some real pain-in-the-ass bugs.  This patch adds teaches
LNVL to ensure that every opcode and instruction has an implementation
on start-up.  It cannot guarantee that those implementations do what
they claim to do, but it at least protects us from forgetting to write
an implementation at all.