lib.deferredModule: Make it properly singular

lib/tests/modules/deferred-module.nix

···
     ({ config, ... }: {
       _file = "generic.nix";
       options.nodes = mkOption {
-        type = lazyAttrsOf (submodule { imports = config.default; });
+        type = lazyAttrsOf (submodule { imports = [ config.default ]; });
         default = {};
       };
       options.default = mkOption {

lib/types.nix

···
       name = "deferredModule";
       description = "module";
       check = x: isAttrs x || isFunction x || path.check x;
-      merge = loc: defs: staticModules ++ map (def: lib.setDefaultModuleLocation "${def.file}, via option ${showOption loc}" def.value) defs;
+      merge = loc: defs: {
+        imports = staticModules ++ map (def: lib.setDefaultModuleLocation "${def.file}, via option ${showOption loc}" def.value) defs;
+      };
       inherit (submoduleWith { modules = staticModules; })
         getSubOptions
         getSubModules;

nixos/doc/manual/development/option-types.section.md

···
 
     It can be set multiple times.
 
-    Module authors can use its value, which is always a list of module values,
-    in `imports` or in `submoduleWith`'s `modules` parameter.
+    Module authors can use its value in `imports`, in `submoduleWith`'s `modules`
+    or in `evalModules`' `modules` parameter, among other places.
+
     Note that `imports` must be evaluated before the module fixpoint. Because
     of this, deferred modules can only be imported into "other" fixpoints, such
     as submodules.

nixos/doc/manual/from_md/development/option-types.section.xml

···
             It can be set multiple times.
           </para>
           <para>
-            Module authors can use its value, which is always a list of
-            module values, in <literal>imports</literal> or in
-            <literal>submoduleWith</literal>’s
-            <literal>modules</literal> parameter. Note that
-            <literal>imports</literal> must be evaluated before the
-            module fixpoint. Because of this, deferred modules can only
-            be imported into <quote>other</quote> fixpoints, such as
-            submodules.
+            Module authors can use its value in
+            <literal>imports</literal>, in
+            <literal>submoduleWith</literal><quote>s
+            <literal>modules</literal> or in
+            <literal>evalModules</literal></quote>
+            <literal>modules</literal> parameter, among other places.
+          </para>
+          <para>
+            Note that <literal>imports</literal> must be evaluated
+            before the module fixpoint. Because of this, deferred
+            modules can only be imported into <quote>other</quote>
+            fixpoints, such as submodules.
           </para>
           <para>
             One use case for this type is the type of a