regexp.h: Move regex flag bit positions.

This moves three bits to create a block of unused bits at the beginning.
The first bit had to be moved to make space for other uses that are
coming in future commits.  This breaks binary compatibility, so might as
well move the other two bits so that all the unused bits are
consolidated at the beginning.

This pool of unused bits is the boundary between the bits that are
common to op.h and regexp.h (and in op_reg_common.h) and those that are
separate.  It's best to have all the unused bits there, so when we need
to use one, it can be taken from either side, as needed, without us
being trapped into having an available bit, but of the wrong kind.
regexp.h Remove unused bit placeholders

We do not need a placeholder for unused flag bits.  And removing them
makes the generated regnodes.h more accurate as to what bits are
available.
regexp.h: Define flag bit directly, not indirectly

This #defined a symbol then did a compile time check that it was the
same as another symbol.  This commit simply defines it as the other
symbol directly, and moves it to above the other definitions, which it
no longer is part of.  This prepares for the next commit.
regexp.h: Make tentative division of free-bit space

This sets a #define to point in the middle of the free-space, so that
bits at either end can be added without having to adjust many other
defines.
regexp.h: Comment shared-pool free bits scheme
op.h: Move flag bits; comment shared-bit scheme

This changes op.h to correspond with regexp.h.  It moves all the used
bits up in the word so that if a new shared bit is added, the #error
will be triggered, alerting the person doing it that things need
adjusting so binary compatibility is preserved.
regcomp.c: Move some statements

These statements are moved to after the debugging code so that the two
functions are essentially identical before them.  This will allow the
two to be combined in a future commit.  I verified by testing that the
debugging info was not affected.
regcomp.c: Extract duplicated code to fcn

This causes the nearly-duplicate code of S_reg_node and S_reganode to be
placed into a single function, S_regnode_guts.

There is one place where it might not be obvious that this doesn't
change things.  And that is under DEBUGGING, reg_node() called

    Set_Node_Offset(RExC_emit, RExC_parse + (op == END));

and reganode called

    Set_Cur_Node_Offset;

However Set_Cur_Node_Offset is defined to be

    Set_Node_Offset(RExC_emit, RExC_parse)

and since op will never be END for reganode, the two statements are
equivalent.
regcomp.h: Use existing macro instead of reinventing
regcomp.h: Remove obsolete #defines

These internal definitions are no longer used.
regcomp.c: Outdent line to align with neighbors
regcomp.h: Add comment
regcomp.sym: ANYOF nodes have an argument

Plus a bitmap, but they always have an argument besides, contrary to
what was specified here.  Future commits rely on this, whereas
heretofore this error was harmless.
regcomp.c: Add a function and use it

This adds a function to allocate a regnode with 2 32-bit arguments, and
uses it, rather than the ad-hoc code that did the same thing previously.
This is in preparation for this code being used in a 2nd place in a
future commit.
regcomp.c: Add assertions

This changes from assuming that certain things are constant to using a
variable instead, and then asserting that the variable matches the
constant.
Up regex flags limit for (??{})

Previously the regex pattern compilation flags needed for this construct
would fit into an 8-bit byte.  This conveniently fits into the flags
structure element of a regnode.  There are changes coming that require
more than 8 bits, so in preparation, this commit adds an argument to the
node that implements (??{}) (31-bits usable for flags), and moves the
storage to that.
op_reg_common.h: #define in terms of more basic one

The mask to copy bits should always include at least the compile-time
bits.  By defining it in terms of the compile-time bits, we make it
easier to change and understand.
Make space for /xx flag

This doesn't actually use the flag yet.
We no longer have to make version-dependent changes to
ext/Devel-Peek/t/Peek.t, (it being in /ext) so this doesn't
op_reg_common.h: White-space only

Align columns vertically
toke.c: Clarify comment