async validate({ clearCurrentResult = false } = {}) {
      /**
       * Allows Application Developer to wait for (async) validation
       * @example
       * ```js
       * await el.validateComplete;
       * ```
       * @type {Promise<boolean>}
       */
      this.validateComplete = new Promise(resolve => {
        this.__validateCompleteResolve = resolve;
      });

      if (this.disabled) {
        this.__clearValidationResults();
        this.__finishValidationPass();
        this._updateFeedbackComponent();
        return;
      }
      // We don't validate before firstUpdated has run
      if (!this.__isValidateInitialized) {
        return;
      }

      this.__prevValidationResult = this.__validationResult;
      if (clearCurrentResult) {
        // Clear ('invalidate') all pending and existing validation results.
        // This is needed because we have async (pending) validators whose results
        // need to be merged with those of sync validators and vice versa.
        this.__clearValidationResults();
      }
      await this.__executeValidators();
    }
Triggered by:
 - modelValue change
 - change in the 'validators' array
 - change in the config of an individual Validator

Three situations are handled:
- a1) the FormControl is empty: further execution is halted. When the Required Validator
(being mutually exclusive to the other Validators) is applied, it will end up in the
validation result (as the only Validator, since further execution was halted).
- a2) there are synchronous Validators: this is the most common flow. When modelValue hasn't
changed since last async results were generated, 'sync results' are merged with the
'async results'.
- a3) there are asynchronous Validators: for instance when server side evaluation is needed.
Executions are scheduled and awaited and the 'async results' are merged with the
'sync results'.

- b) there are MetaValidators. After steps a1, a2, or a3 are finished, the holistic
MetaValidators (evaluating the total result of the 'regular' (a1, a2 and a3) validators)
will be run...

Situations a2 and a3 are not mutually exclusive and can be triggered within one `validate()`
call. Situation b will occur after every call.

@param {{ clearCurrentResult?: boolean }} opts