Closes #575 Better error handling via the new options error and processSource

From the readme:

Options

• error The error handler function used for the <%= construct and
  <%- construct. When an error is thrown within these constructs, the error handler is
  called. It receives two arguments: err (type unknown), which is the error object
  that was thrown; and escapeFn (type (text: string) => string), which is the current
  function for escaping literal text. The error function may return a string, and if it
  does, that value is inserted into the template instead.
• processSource Callback that is invoked with the generated source code of the
  template, without the header and footer added by EJS. Can be used to transform the source.
  The callback receives two arguments: source (string), which is the generated source text;
  and outputVar (type string), which is the name of the variable that contains the template
  text and can be appended to. The callback must return a value of type string, which is the
  transformed source. One use case for this callback is to wrap all individual top-level statements
  in try-catch-blocks (e.g. by using a parser such as acorn and a stringifier such as astring)
  for improved error resilience.

Error handling

In an ideal world, all templates are valid and all JavaScript code they contain
never throws an error. Unfortunately, this is not always the case in the real
world. By default, when any JavaScript code in a template throws an error, the
entire templates fails and not text is rendered. Sometimes you might want to
ignore errors and still render the rest of the template.

You can use the error option to handle errors within expressions (the <%=%>
and <%-%> tags). This is a callback that is invoked when an unhandled error
is thrown:

const ejs = require('ejs');

ejs.render('<%= valid %> <%= i.am.invalid %>', { valid: 2 }, {
  error: function(err, escapeFn) {
    console.error(err);
    return escapeFn("ERROR");
  }
});

The code above logs the error to the console and renders the text 2 ERROR.

Note that this only applies to expression, not to other control blocks such
as <%if (something.invalid) { %> ... <% } %>. To handle errors in these cases,
you e.g. can use the processSource option to wrap individual top-level
statements in try-catch blocks. For example, by using acorn and astring
for processing JavaScript source code:

const ejs = require('ejs');
const acorn = require('acorn');
const astring = require('astring');

ejs.render('<%= valid %> <%if (something.invalid) { %> foo <% } %>',
  { valid: 2 },
  {
    // Wrap all individual top-level statement in a try-catch block
    processSource: function(source, outputVar) {
      const ast = acorn.parse(source, {
        allowAwaitOutsideFunction: true,
        allowReturnOutsideFunction: true,
        ecmaVersion: 2020,
      });
      return ast.body
        .filter(node => node.type !== "EmptyStatement")
        .map(node => {
          const statement = astring.generate(node, { indent: "", lineEnd: "" });
          switch (node.type) {
            case "ReturnStatement":
            case "TryStatement":
            case "EmptyStatement":
              return statement;
            default:
              return `try{${statement}}catch(e){console.error(e);${outputVar}+='STATEMENT_ERROR'}`;
          }
        })
        .join("\n");
  },
});

The above code logs the error to the console and renders the text 2 STATEMENT_ERROR.