doc: example generating keypairs with WebCrypto & node:crypto

```js
'use strict';

let Fs = require('node:fs/promises');

async function generateKeyPair(algo) {
let keyPair = await crypto.subtle.generateKey(algo, true, ['sign', 'verify']);

let name = algo.namedCurve || algo.name;

let privateKeyAb = await crypto.subtle.exportKey('pkcs8', keyPair.privateKey);
let privateKeyDER = new Uint8Array(privateKeyAb);
let privateKeyPath = `./key.${name}.der`.toLowerCase();
await Fs.writeFile(privateKeyPath, privateKeyDER);

let publicKeyAb = await crypto.subtle.exportKey('spki', keyPair.publicKey);
let publicKeyDER = new Uint8Array(publicKeyAb);
let publicKeyPath = `./pub.${name}.der`.toLowerCase();
await Fs.writeFile(publicKeyPath, publicKeyDER);

console.info(`Key pair generated and saved as ${privateKeyPath} and ${publicKeyPath}`);
}

let Crypto = require('node:crypto');

async function generateSecp256k1KeyPair() {
return new Promise(function (resolve, reject) {
Crypto.generateKeyPair(
'ec',
{
namedCurve: 'secp256k1',
publicKeyEncoding: {
type: 'spki',
format: 'der',
},
privateKeyEncoding: {
type: 'pkcs8',
format: 'der',
},
},
async function (err, publicKey, privateKey) {
if (err) {
return reject(err);
}

await Fs.writeFile('./key.secp256k1.der', privateKey);
await Fs.writeFile('./pub.secp256k1.der', publicKey);

console.info(
'secp256k1 key pair generated and saved as ./key.secp256k1.der and ./pub.secp256k1.der',
);
},
);
});
}

async function main() {
await generateKeyPair({ name: 'Ed25519' });
await generateKeyPair({ name: 'ECDSA', namedCurve: 'P-256' });
// this should be possible with WebCrypto as well, but I don't know the name to use
//await generateKeyPair({ name: 'ECDSA', namedCurve: 'secp256k1' });
// it does work with node:crypto
await generateSecp256k1KeyPair();
}

main().catch(function (err) {
console.error(err.stack);
process.exit(1);
});
```

Comienza con el ejemplo de JavaScript del issue, especialmente con generateKeyPair, generateSecp256k1KeyPair y main, y compara su uso de WebCrypto y node:crypto. Confirma los nombres de algoritmo documentados y los archivos generados esperados, incluida la cuestión abierta sobre la compatibilidad con secp256k1 en WebCrypto; se considera terminado cuando el ejemplo cubra claramente la generación de pares de claves prevista.

Escrito por el modelo de indexación a partir del texto del issue.