perl.h: Move #if

Some of the things in its scope should be defined even if we don't want
to use LC_NUMERIC.  That there have been no reports of compilation
failures from the field indicates that the Configure to exclude it
hasn't been used.
Localeconv() should be independent of 'use locale'

localeconv() should return the values for the underlying locale of
the program regardless of whether the calling place is within the
scope of "use locale" or not.  Otherwise, it makes no sense to call it
from outside such scope, and a pure perl module that calls it on behalf
of a caller would likely get it wrong.

In earlier versions of Perl the LC_NUMERIC category was initialized to
C, but was changed by the first setlocale() anywhere in the process.  It
is rare to call localeconv() without first having done a setlocale().
But to solve other bugs, future commits will keep LC_NUMERIC in the C
locale except during such operations where it should be the underlying
locale.  localeconv() is such a place, so this commit is being done
before the later ones so it doesn't break.
Swap #if sense for localeconv()

When the else clause is trivial, and the if clause is long, It's far easier to understand if they're swapped
so the short clause and the else are right after the if.
Exclude undefined hash elements from localeconv()

A given platform may not have all the localeconv elements available, or
Perl may be compiled to not use them.  Don't define hash elements for
the missing ones.
Set utf8 flag properly in localeconv

 Rare, but not unheard of, is for the strings returned by localeconv to
 be in UTF-8.  This commit looks for and sets the UTF-8 flag if they are.
 so encoded.

 A private function had to changed from static for this.  It is renamed
 to begin with an underscore to emphasize its private nature.
'use locale' no longer ever fails.to compile

Thus we can skip the machinations we used to do to make sure things
compiled.
Avoid locale function overhead

For the LC_NUMERIC locale category, one can swap between setlocale being
to "C" or to the underlying locale.  Perl keeps track of the state
using two boolean variables.  By testing these before calling the swap
functions, we can skip calling them if the current state is the one we
want to be in, and avoid the function call overhead, as the function
becomes a no-op if the current state is the desired one.
perllocale: Wrap some text in C<...>
Make sure locale set right for radix parsing

I haven't found a test case this fails for in v5.20, but I'm sure there
is one.  But two commits from now would fail if this wasn't done.
numeric.c: White-space only

The previous commit added a block around this code, so indent
correspondingly.
Keep LC_NUMERIC in C locale, except for brief periods

This is for XS modules, so they don't have to worry about the radix
being a non-dot.  When the locale needs to be in the underlying one, the
operation should be wrapped using macros for the purpose.  That API may
change as we gain experience in 5.21, so I'm not including it now.
Fix up LC_NUMERIC wrap macros

perl.h has some macros used to manipulate the locale exposed for the
category LC_NUMERIC.  These are currently undocumented, but will need to
be documented as the development of 5.21 progresses.  This fixes these
up in several ways:

The tests for if we are in the correct state are made into macros.  This
is in preparation for the next commit, which will make one of them more
complicated, and so that complication will only have to be in one place.

The variable declared by them is renamed to be preceded by an
underscore.  It is dangerous practice to have a name used in a macro, as
it could conflict with a name used by outside code.  This alleviates it
somewhat by making it even less likely to conflict.  This will have to
be revisited when some of these macros are made part of the public API.

The tests to see if things need to change are reversed.  Previously we
said we need to change to standard, for example, if the variable for
'local' is set.  But both can be true at the same time if the underlying
locale is C.  In this case, we only need to change if we aren't in
standard.  Whether that is also local is irrelevant.
Allow dynamic lock of LC_NUMERIC

When processing version strings, the radix character must be a dot even
if we otherwise would be using some other character.  vutil.c
upg_version() changes to the dot, but calls sv_catpvf() which may try to
change the character to something else.  This commit introduces a way to
lock the character to a dot around the call to sv_catpvf()

vutil.c is cpan-upstream, but already blead and cpan have diverged, so
this just updates the SHA of the new version