utf8.h, regcomp.c: Use mnemonics for Unicode chars

Add a mnemonic definition for these three code points.  They are
currently used in only one place, but future commits will use them
elsewhere.
embed.fnc: Remove duplicate entry
regcomp.c: Change and comment a problematic #define

As noted in the new comments, there is no out-of-bounds code point, so
this should not be used as such; and it turns out, it really isn't.
But this is a fall-back in case code is changed to not set the variable
that this initializes, and the comment will prevent someone else from
wasting their time trying to figure out why this is like this.
regcomp.c: Correct outdated comment
mktables: Generate new table for foldable chars

This table consists of all characters that participate in any way in a
fold in the current Unicode version.  regcomp.c currently uses the Cased
property as a proxy for these.  This information is used to limit the
number of characters whose folds have to be dealt with in compiling
bracketed regex character classess.   It turns out that Cased contains
more than 1300 more code points than actually do appear in folds, which
means potential extra work for compiling.  Hence this patch allows that
work to be avoided.

There are a few characters in this new table that aren't in Cased, which
are potential bugs in the old way of doing things.  In Unicode 6.1,
these are:  U+02BC MODIFIER LETTER APOSTROPHE, U+0308 COMBINING
DIAERESIS, U+0313 COMBINING COMMA ABOVE, and U+0342 COMBINING GREEK
PERISPOMENI.  I can't figure out how these might be currently causing a
bug, but this patch fixes any such.
regcomp.c: Only try to fold foldable chars

This uses the new table that a previous commit caused mktables to
generate which more precisely determines which Unicode characters
participate in folds.  This avoids trying to calculate a fold that we
can know beforehand doesn't have a fold.
regcomp.c: Use macro for clarity

It's kind of obscure what this test is doing, so change it into a macro
to clarify things
regcomp.c: Use data structure properties to remove tests

The ANYOF_foo character class #defines really form an enum, with the
property that the regular one is n, and its complement is n+1.  So
we can replace the tests in each case: of the switch, with a single test
afterwards.
regcomp.c: Refactor new charclass optimizations

Commits 3a64b5154fffec75126d34d25954f0aef30d9f8a and
3172e3fd885a9c54105d3b6156f18dc761fe29e5 introduced some optimizations
into the handling of bracketed character classes with just a single
element.

In working on other optimizations, I realized that it would be better to
put these all in one spot, instead of doing things partially and setting
flags to pass to other areas of the routine.

This commit moves all the processing to a single spot, which gets called
only after we know that there will be just one element in the character
class.

I also realized that the [0-9] optimization should strictly not be done
under locale.  There is no test for this, as actually this would only be
a problem if a locale was in violation of the C standard.  But (most) of
the rest of Perl doesn't assume that locales are well-behaved in this
regard, so now this code doesn't either.
regcomp.c: White-space, comments only

This fixes some nits in a some comments, adds some comments, but mostly
just indents and outdents to reflect a new outer block, and to fit
within 80 columns
regcomp.c:  Optimize [^\n] into \N

This optimization is a big win, as it takes less space, and completely
avoids any swash hash creation, and use.
regen/regcomp.pl: Allow ';' in comments

If a comment contained a semi-colon, the regular expression's greedy
quantifier would think the portion of the comment before it was part of
the data to be processed
regcomp.sym: Correct and add comments
regcomp.c: Extract code to inline function

Future commits will use this paradigm in additional places, so extract
it to a function, so they all do things right.  This isn't a great API,
but it works for the few places this will be called.
handy.h: refactor some macros to use a new one in common.

This creates a new, unpublished, macro to implement most of the other
macros.  This macro will be useful in future commits.
handy.h: l1_charclass.h: Add bit for matching ASCII

This does not replace the isASCII macro definition, as I think the
current one is more efficient than this one provides.  But future
commits will rely on all the named character classes (e.g.,
/[[:ascii:]]/) having a bit, and this is the only one missing.
handy.h: Reorder some #defines

They are now ordered in the same order as the similar #defines in
regcomp.h.  This will be useful in later commits
handy.h: Renumber character class bits

These are renumbered so that the ones that correspond to character
classes in regcomp.h are related numerically as well.  This will prove
useful in future commits.
handy.h: Move bit shifting into base macro

This changes the #defines to be just the shift number, while doing
the shifting in the macro that the number is passed to.  This will prove
useful in future commits
regcomp.c: Remove duplicate assignments

These variables are already set to the same values a few lines up.