I never acquainted with types.nix, is there some fundamental reason that either of two freeform submodules couldn't work when left and right have disjoint explicit options?

with import <nixpkgs/lib>;

evalModules {
  modules = [
    {
      options.foo = mkOption {
        type =
          types.either
            (types.submodule {
              freeformType = types.attrsOf types.str;
              options.marker_a = mkOption {
                type = types.str;
              };
            })
            (
              types.submodule {
                freeformType = types.attrsOf types.str;
                options.marker_b = mkOption {
                  type = types.str;
                };
              }
            );
      };
      config.foo = {
        marker_b = "bar";
      };
    }
  ];
}

{ foo = { marker_a = «error: The option `foo.marker_a' was accessed but has no value defined. Try setting 
the option.»; marker_b = "bar"; }; }

I believe the issue is the left and right type's check function.

either will use whichever type fist passes check value, and iirc submodules just use something like check = isAttrs

nix-repl> with lib.types; (listOf int).check [ true false "hello" ]
true

nix-repl> with lib.types; (addCheck (listOf int) (builtins.all builtins.isInt)).check [ true false "hello" ]
false

The other issue with marker options (marker_a, marker_b) is how should definitions be merged that don't include the marker? E.g.

foo = lib.mkMerge [
  { something_freeform = "hi"; }
  { marker_a = "there"; }
]

You don't know which marker is defined until all merging is done.

In a simple case like this, you could refactor this as one submodule with both markers, and then add some extra logic/conditions within the submodule and/or in the optinon's final apply function.

One way you could work around this is to add an internal final option within the submodule and then map to it in the apply function:

foo = mkOption {
  type = types.submodule (
    { config, options, ... }:
    {
      freeformType = types.attrsOf types.str;
      options.marker_a = mkOption {
        type = types.str;
      };
      options.marker_b = mkOption {
        type = types.str;
      };
      options.__result = mkOption {
        type = config._module.freeformType;
        internal = true;
      };

      config.__result =
        let
          cfg = builtins.removeAttrs config [
            "_module"
            "marker_a"
            "marker_b"
            "__result"
          ];
        in
        if options.marker_a.isDefined then
          cfg // { inherit (config) marker_a; } # TODO
        else if options.marker_b.isDefined then
          cfg // { inherit (config) marker_b; } # TODO
        else
          cfg # TODO: (empty? no marker?)
          ;
    }
  );

  apply = value: value.__result;
}

trace: { below = "_"; }                                                                                                                                                                                              
trace: { marker_b = "bar"; }                                                                                                                                                                                         
trace: { above = "_"; }                                                                                                                                                                                              
trace: { below = "_"; }                                                                                                                                                                                              
{ foo = { above = "_"; below = "_"; marker_b = "bar"; }; } 

For modules:

    { foo = { above = "_"; }; }
    {
      foo.marker_b = "bar";
    }
    { foo = { below = "_"; }; }

trace: { below = "_"; }                                                                                                                                                                                              
trace: { marker_b = "bar"; }                                                                                                                                                                                         
trace: { above = "_"; }                                                                                                                                                                                              
trace: { below = "_"; }                                                                                                                                                                                              
{ foo = { above = "_"; below = "_"; marker_b = "bar"; }; } 

For modules:

    { foo = { above = "_"; }; }
    {
      foo.marker_b = "bar";
    }
    { foo = { below = "_"; }; }

This won't support foo = { config,...}: { marker_b = "bar"; }.

Type checking is done before merging, but after resolving mkIf (etc) wrappers.

Type checking is used to determine which type to use for merging.

(
  { options, ... }:
  {
    freeformType = attrsOf (
      if options.marker_a.isDefined && options.marker_b.isDefined then
        throw "both `${options.marker_a}' and `${options.marker_b}' are defined"
      else if options.marker_a.isDefined then
        a
      else if options.marker_b.isDefined then
        b
      else
        throw "neither `${options.marker_a}' or `${options.marker_b}' are defined"
    );
  }
)