New loader expectations on the output of the compiler.

The code for a given predicate in a module is described in three layers.  The switch_on_reg layer, the clause layer, and the switch_on_term layer.

The switch on reg layer is only present in a predicate which is extensible by a module higher up the accumulation tree, (so it appears in the next clause table of the module) in which case it must be present.  If this layer is present, the address in the corresponding search table should point to a "switch_on_reg" instruction, which has arguments L1 and L2, where L1 points to a "try n L2" statement followed by "trust_ext", and L2 points to the first instruction of the clause layer.  If there is no switch_on_reg layer, the predicate table should point directly to first instruction of the clause layer.

The clause layer consists of code blocks linked by "try_me_else" and related instructions.  If the definition consists of only one clause, the instruction pointed is something other than try_me_else, and preceding that instructions there must be an "unused" space sufficient to contain a try_me_else instruction (presumably created by emitting a try_me_else instruction which is not referenced.)

Each block of code in the clause layer may have a switch_on_term layer, which is defined as normal, except that the variable term of the switch_on_term instruction must point to either a try_me_else instruction, or some other instruction and an undefined space large enough for a try_me_else instruction (as in the clause layer).

Also, uses of the "call" and "execute" instruction in the bytecode file will refer to the index of called predicate in the constant table, not code offsets.

The following assumptions are made about the length of instructions.
try_me_else, retry_me_else, and trust_me all have the same length.
try and retry have the same length.
try_else, retry_else, and trust have the same length.
call and call_name have the same length.
execute and execute_name have the same length.