(PUP-2995) Proposal for processing an external trusted OID yaml file

* This patch is a proposal(that's why filename is hard-coded) that allows trusted facts users to map their
custom OIDs to user-friendly names that can be used in puppet manifests.

For instance a mapping file such as

```
# /etc/puppet/trusted_oid_mapping.yaml
---
oid_mapping:
  - ['1.3.6.1.4.1.34380.1.2.1.1', 'shortname', 'Long name']
  - ['1.3.6.1.4.1.34380.1.2.1.2', 'othershortname', 'Other Long name']
```

could be used to obtain `$trusted[extensions][shortname]`.


* If the oid mapping is not done at this level, each site that wants to
use custom trusted facts extensions would have to write its own
`oid_to_name` puppet function that traverse the `$trusted[extensions]`
hash and replace _OIDs_ with friendly names.

_Note_: I couldn't succeed to add a configuration option for this as the
`puppet/ssl/oids` library seems to be loaded very early and I don't have much time to dig deeper.
I've just tried a stupid program like this one to test what happens if we register the same OID multiple times.
The `OBJ_create()` function is the one that is used internally by openssl's ruby bindings (according to my googling).

```
/* cc asn1.c -o asn1 -lssl && ./asn1 */
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<openssl/objects.h>

int main(int argc, char *argv[])
{

  int new_nid, new_nid2;
  ASN1_OBJECT *obj, *obj2, *retrieved;

  new_nid = OBJ_create("1.2.3.4", "NewOID", "New Object Identifier");
  fprintf(stdout, "new_nid = %d\n", new_nid);
  obj = OBJ_nid2obj(new_nid);

  new_nid2 = OBJ_create("1.2.3.4", "NewOID", "New Object Identifier");
  fprintf(stdout, "new_nid2 = %d\n", new_nid2);
  obj2 = OBJ_nid2obj(new_nid2);

  fprintf(stdout, "obj = %p, obj2 = %p\n", obj, obj2);
  fprintf(stdout, "obj and obj2 are %s objects\n",
    OBJ_cmp(obj, obj2) == 0 ? "same" : "different");

  // Try to retrieve base on the short name
  fprintf(stdout, "Using *OBJ_txt2obj()*:\n");
  retrieved = OBJ_txt2obj("NewOID", 0 /* no_name */);
  fprintf(stdout, "retrieved = %p\n", retrieved);
  fprintf(stdout, "retrieved object is %s object as obj\n",
    OBJ_cmp(obj, retrieved) == 0 ? "the same" : "a different");
  fprintf(stdout, "retrieved object is %s object as obj2\n",
    OBJ_cmp(obj2, retrieved) == 0 ? "the same" : "a different");

  fprintf(stdout, "Using *OBJ_sn2nid() and OBJ_nid2obj()*:\n");
  retrieved = OBJ_nid2obj( OBJ_sn2nid("NewOID") );
  fprintf(stdout, "retrieved = %p\n", retrieved);
  fprintf(stdout, "retrieved object is %s object as obj\n",
    OBJ_cmp(obj, retrieved) == 0 ? "the same" : "a different");
  fprintf(stdout, "retrieved object is %s object as obj2\n",
    OBJ_cmp(obj2, retrieved) == 0 ? "the same" : "a different");


  return(0);
}
```

and it gave me the following output

```
new_nid = 920
new_nid2 = 921
obj = 0x113d210, obj2 = 0x113d430
obj and obj2 are same objects
Using *OBJ_txt2obj()*:
retrieved = 0x113d430
retrieved object is the same object as obj
retrieved object is the same object as obj2
Using *OBJ_sn2nid() and OBJ_nid2obj()*:
retrieved = 0x113d430
retrieved object is the same object as obj
retrieved object is the same object as obj2
```

so I think that now I can say that when we register the same OID multiple times:
* only the last one will be used
* we consume useless memory

So I think that we should absolutely avoid this.