Bullets: Add a handler for <actionRef/> nodes

This adds a currently undefined ‘executed-action’ instruction which we
will later build upon to execute referenced <action>’s.
Add a test-case for testing out <actionRef/> support

Bullet patterns currently do not support <actionRef/>, but when they
do this is the type of pattern we want to behave correctly.
Change the bullet prototype to fire the <actionRef/> test pattern

Now when we press ‘4’ we fire the ‘test-14.xml’ pattern instead.  That
is the pattern file that is our <actionRef/> test-case.
Ensure that <actionRef/> nodes have a ‘label’ attribute

Without one they are meaningless and represent an error in the pattern
definition since we cannot reference an unlabeled action.
Fix a typo in the node handler for <actionRef/>
Implement first version of instruction handler for ‘execute-action’

This should finish processing <actionRef/> nodes by inserting their
instructions into the list of instructions for the pattern.  It
functions, but not exactly as expected.  There is a noticeable delay
between the first shot (when we first process the labeled action) and
the second unlabeled action where we reference the previous action
twenty times.  This creates an overlap in bullets.  Adding <wait> tags
to both the labeled and unlabeled action do nothing to prevent that
overlap, which means we are not be correctly inserting the referenced
instructions into the list of things-to-do.

Printing out the pattern shows us this compiled instruction set:

    <Pattern assets/patterns/test/test-14.xml
            1: fire = basic
            2: repeat-start = 0
            3: execute-action = fast-aim
            4: repeat-end = 2
            5: fire = basic
            6: fire = basic
            7: fire = basic
            8: fire = basic
            9: fire = basic
            10: fire = basic
            11: fire = basic
            12: fire = basic
            13: fire = basic
            14: fire = basic
            15: fire = basic
            16: fire = basic
            17: fire = basic
            18: fire = basic
            19: fire = basic
            20: fire = basic
            21: fire = basic
            22: fire = basic
            23: fire = basic
            24: fire = basic
            25: fire = basic

    Delayed Instructions:
    >

We need to test out where <wait> and other instructions end up
depending on where we place them in order to control the affected
layout of instructions.
Show the pattern filename when the ‘execute-action’ instruction fails
Merge branch 'master' into ejmr/actionref-support

Fixed a merge conflict of comments between ‘execute-action’ and
‘play-sound’ instruction handlers.

* master: (289 commits)
  Provide support to rotate enemies to orient with the path they are following; apply to flies
  Make bees a little larger
  Make game region a little wider (aspect ratio of 3:4 instead of 2:3)
  Render the score on the sidebars
  Make bullet movement framerate independent
  Made player bullets deal more damage and move more quickly
  Render a healthbar for bosses and midbosses
  Make player bullets smaller
  Fix bug where image-type bullets were rendering full black
  Uncomment <playSound> in the player shot definition
  Center image-type bullets
  Fix problem with ‘play-sound’ instruction preventing multiple shots
  Refactor wait command to use a countdown timer and to use ticks (1/60th of a second) instead of seconds.
  Remove deprecated beeShootSound variable.
  Fix the order of elements in the BulletMLX DTD
  Fix <shape> definition by telling it to accept PCDATA
  Correct an error in the BulletMLX DTD with <shape> definition
  Remove Pattern.__index, which was adding deltaTime to the pattern redundantly
  Remove spurious debug output
  Remove spurious debug output
  ...

Conflicts:
	src/bullet.lua
Make the comment format for instruction handlers consistent

This patch adds a line of whitespace before the name and value
descriptions for each instruction handler.  Just a little touchup to
the readability of the code.
Add color to the test bullet pattern for testing <actionRef/>

Now that bullets are black by default we need to change the color so
it is easier to see them appear.
Make the background of the bullet prototype white

This makes the ships look better, as overall we are going with a
bright background in the game.  It also makes test patterns easier to
see.  The ‘Bullet Prototype’ text at the top of the screen is now
black so that it stands out against the white background.
Improve a comment inside the instruction handler for ‘wait’

The line was slightly too long (when I have split windows in my
editor), and I wanted to clarify that the definition of ‘tick’ in that
context came from BulletMLX.
Add a utility function to the bullet prototype for adding patterns

This replaces calls to ‘table.insert(PATTERNS, …)’ that performs some
debugging output.  This will help debug all patterns in general, but
specifically it is to help debug pattern test-14.xml right now.
Add a <wait> to patterns/test-14.xml

It seems that instructions to wait do not properly appear in patterns
when we use <actionRef/> nodes.  So this patch adds a <wait> node to
our test pattern to help figure out this problem.
Fix the DOCTYPE and remove the namespace of patterns/test-14.xml
Add ‘immediateInstructions’ to the Pattern class

This patch does not use the new property.  It only declares and
documents its intended use.  However, we do modify the tostring()
meta-method to show immediate instructions for debugging.
Put the <wait> node in the right place in test pattern 14

The node cannot be a child of <fire> or the engine will create no
instruction for it.
Add a utility function to add immediate instructions to Patterns

Unlike addInstruction(), this function exists only in the Pattern code
because we do not intend to use it elsewhere in other modules.
Check waitTimer in Pattern before any instructions

We want to make sure no instruction holds up <wait>.
Process immediate instructions as part of ‘execute-action’

This patch changes the ‘execute-action’ instruction to add all of the
instructions of the referenced <action> to the immediate instruction
list instead of the normal one.  We do this by temporarily rebinding
the Pattern:addInstruction() method.  Then in Pattern:update() we look
for immediate instructions first, run them like normal instructions,
but we remove them from the list if they are successful.  This will
break things like <repeat> loops in referenced <action> nodes, but
after this patch the ‘wait’ instruction does properly appear in
test-16.xml, the test pattern for <actionRef/>.

However, the pattern still does not wait long enough.