regcomp.c: Use a parameter to simplify some code

When parsing \p{} outside of a bracketed character class, code in
regcomp.c has pretended it is a bracketed character class by changing
and restoring the parsing pointers, and then calling the charclass
handler.  This code can be simplified by instead passing a flag to the
handler meaning to just parse one item.  The faking is simpler there,
with no restoring necessary.  Also we can eliminate the duplicate
handling of special cases.

Future commits will make more extensive use of this mechanism.
Revise calling sequences for grok_bslash_[xo]

By passing the address of the parse pointer, the functions can advance
it, eliminating a parameter to the function, and simplifying the code in
the caller.
Better error pos for grok_bslash_[xo]

These functions advance the parse pointer for the caller.  The regex
code has the infrastructure to output a marker as to where the error
was.  This commit simply moves the parse pointer past all the legal
digits in the input, which are likely supposed to be part of the number,
which makes it likely that the missing right brace point is just past
those.
Add optional strict mode to grok_bslash_[xo]

This mode croaks on any iffy constructs that currently compile.  It is
not currently used; documentation of the error messages will be
delivered later.
dquote_static.c: White-space only; no code changes

This properly indents a newly-formed block
Create new warnings category experimental::regex_sets

This on-by-default warning will be raised upon use of the
soon-to-be-delivered regex sets feature.  The syntax used is currently
invalid, so no feature activation is necessary.

The purpose of this warning is to make sure that any user is properly
notified that this feature is experimental and subject to change
regcomp.c: Omit unnecessary 'else's

The 'if' part of this croaks, so there is no need to specify this as an
'else'
regcomp.c: Save a test by moving a line of code

The condition for executing this moved code are met by the else clause a
few lines below.
dquote_static.c: refactor common code to initialization

This flag bit is set in both branches of the code; it might as well be
initialized instead.
grok_bslash_[ox]: Add param to silence non-portable warnings

If a hex or octal number is too big to fit in a 32 bit word, grok_oct
and grok_hex by default output a warning that it is a non-portable
value.  This new parameter to the grok_bslash functions can cause them
to shut up those warnings.  This is currently unused, but will be needed
in future commits.
regcharclass.h: Add macro for finding pattern white space

This Unicode property will be used in future commits
regcomp.c: Remove unnecessary variable

This variable is used just in the statement following it.  Its value
doesn't need to be saved, can just combine the statements
regcomp.c: Add a vFAIL4 macro

This one is missing.
regcomp.c: Add parameter to regclass()

This parameter allows the caller to specify whether multi-character
folds should be allowed or not.  In general it should, and in the case
where this commit says it shouldn't, they never are returned anyway from
Unicode properties.

This capability will be put to real use by future commits
regcomp.c: Add parameter to regclass()

This parameter silences warnings for non-portable characters.  It
currently is always FALSE, meaning that warnings are given.
regcomp.c: Comments, white space

This also reverses the order of 2 macro calls in 2 places which will be
useful for future commits.
regcomp.c: Add function to skip pattern white space

The plan is to eventually convert all of regcomp to use this for white
space ignoring under /x, but this will be used for now in just the new
syntax for (?[ ]), coming in a few commits.  Until then, this function
is unused.
regcomp.c: Add capability for strict [:posix:]

This adds a parameter to regpposixcc() to enforce stricter rules on the
posix class syntax.  It is currently unused
regcomp.c: Add capability for stricter parsing of []

This adds the capability, currently unused, of forbidding certain things
in [bracketed] character classes.  Included are things that warn bug
still compile, such as false ranges, [\d-\w], and unrecognized escapes.

Also forbidden are potentially ambiguous cases where \x (without braces)
isn't followed by exactly two hex digits, or \000 where the number of
octal digits isn't precisely three.
regcomp.c: Add capability for ignoring white space inside []

This is currently unused, but allows pattern white space to be used
inside [bracketed] character classes.  When this is on, literal white
space must be escaped by a preceding backslash to be counted.