Add support for deferred identity prompting

The password callback which we usually supply to NSS already gets a
pointer to the pkinit_identity_crypto_context structure, but it needs to
be passed the name of the identity for which it's being called.

If it gets a name, and it's deferring prompting, just add the identity
to the list of deferred identity prompts, it's not going to be called if
its result is not needed.  Otherwise, check for a password that's been
stashed for its use for that identity, and return a copy of it if it's
found.  If none of that works, try to use the prompter callback.

In various places where we attempt to load identity information, ignore
failures so yield new information if we're deferring prompts.
Add support for deferred identity prompting

Add a password to the set of things that we can pass to a PEM password
callback and the function we use for loading PKCS12 bundles.  If we're
meant to defer identity prompts, just store the name of the identity
which we're loading.  Otherwise, if we're passed a password, use it.
Otherwise, use the prompter callback.

Add a password to the set of things that we can pass to the function
that we use for logging in to PKCS11 tokens, too, but if we're deferring
identity prompts, just return the identity name without doing anything
else.  If not, and we're passed a password, use that.  Otherwise, try to
use the prompter callback to get one.
Pass deferred identity prompts to the responder

Use the list of deferred identity prompts and warnings, which we have
after calling pkinit_identity_initialize(), to build a list of questions
for responder callbacks to answer, and before calling
pkinit_identity_prompt() to actually load identities that are protected,
save any passwords and PINs which a responder callback may have
supplied, in case there's no prompter callback.
Shorten whitespace in the middle of debug messages
Add PIN hints to password prompts when using NSS

When built with OpenSSL, we warn of locked or possibly-soon-to-be-locked
PINs on tokens, so we should do so when we're built with NSS, too.
Traverse tokens like we do with OpenSSL for NSS

When built with NSS, change our token traversal strategy to mimic the
way we do things when we're using OpenSSL: forget about slot names, and
only look at the specified token, or the first one if one isn't
specified.
Also pass PIN warnings to responder callbacks
Pass a distinguishable identity name to responders

When using a PKCS#11 token, build an identity name using the token name
and slot ID, and pass that to the password prompter, so that even if the
user or configuration didn't originally specify either, we can be more
sure that we're applying any values we get back to the right token.
An encrypted copy of privkey.pem, for testing

A copy of the private key from privkey.pem, encrypted with a passphrase
for use in testing.  Generated by running:
openssl rsa -in privkey.pem -des3 -passout pass:encrypted -out privkey-enc.pem
Add a PKCS#12 bundle for testing

Add a PKCS#12 bundle which we can use for testing.  Generated with:
openssl pkcs12 -inkey privkey.pem -in kdc.pem -export -des3 -passout pass: -out kdc-enc.p12
Add an encrypted PKCS#12 bundle for testing

Add a PKCS#12 bundle encrypted with a non-empty passphrase, for use in
tests.  Generated with:
openssl pkcs12 -inkey privkey.pem -in kdc.pem -export -des3 -passout pass:encrypted -out kdc-enc.p12
Add a helper for checking responder challenges

This test helper takes two options and one argument.

./misc/test_responder [-x challenge] [-X preauth_option] principal
 -X preauth_option -> preauth options, as for kinit
 -x challenge      -> expected responder challenge, of the form
                      "question=challenge"
 principal         -> client principal name

If the responder callback isn't called, that's treated as an error.
If the responder callback is called and the challenge associated with
the specified question doesn't parse as JSON, a literal string compare
is done, otherwise both values are parsed as JSON and then re-encoded
before comparison.  In either case, the comparison must succeed.  Any
missing data or mismatches are treated as errors.
Add various PKINIT-with-responder tests
Don't fail if a candidate certificate has no SANs
Rework PEM loading

* Load certificates before keys, to work around a bug in the PEM module.
* Use a better method for finding the certificate that we've loaded,
  after we've loaded it.
Include error names in these debug messages
Handle encrypted PEM files

The PEM module sets its needs-login flag when we pass it an encrypted
PEM file, and we need to be ready to give it _something_ before we
continue attempting to import any other data.
Don't save keys we can't encrypt; just delete them

If we have trouble loading a private key, don't bother hanging on to it,
just remove it.  We can always come back and try to load it again later.