rules: cuda, hip and sycl gain the flag pass-through ascendc already had

`mcpp.tools.island::force_include_flags` returns the flags that make a
compiler read the generated boundary header before the island's first line,
and three of the four device rules had no way to deliver them. Measured on
`examples/09-heterogeneous/cuda`: the island is compiled by nvcc, or by
clang in CUDA mode, on a command line the rule assembles -- a driver mcpp
did not invoke, which inherits nothing from `mcpp::cflag` or
`mcpp::cxxflag`.

The project-wide channels are not merely too wide for the job, they are
wrong for it. `cxxflag` forces the header into every C++ translation unit,
including the seam `src/app.cppm`, and a module interface unit must begin
with `export module` -- declarations ahead of that line are ill-formed.

`mcpp.rules.ascendc` already had `options::flags`, appended last. The other
three now carry the same field with the same position and the same
pass-through-unexamined contract, because one rule with it and three
without is the shape where a project's build program works for one backend
and not the next -- which is what a seam exists to prevent.

Verified end to end on this host: the cuda example's island compiles with
`-include .../app.kernels.h` on its own command line, and the artifact runs
on an RTX 4080.

Author: Sunrisepeak

rules/cuda.cppm

@@ -97,6 +97,17 @@ struct options {
     // dependency's directory here, and it knows it only as the absolute path
     // `mcpp::dep_dir` answered with.
     std::vector<std::string> includes;
+    // FLAGS FOR THE ISLAND'S COMPILER, PASSED THROUGH UNEXAMINED.
+    //
+    // A device compiler is a separate driver with its own command line, and
+    // `mcpp::cflag`/`mcpp::cxxflag` reach mcpp's compiler rather than this one.
+    // The case this exists for is `mcpp.tools.island`, whose
+    // `force_include_flags` makes the island read its generated boundary header
+    // before its first line -- so the island names no generated file and the
+    // project has no header of its own. Project-wide flags cannot do that job:
+    // forcing a header into every C++ translation unit puts declarations ahead
+    // of `export module`, which no module interface unit accepts.
+    std::vector<std::string> flags;
     std::string out_dir = std::string(mcpp::out_dir());
 };
 
@@ -728,6 +739,7 @@ inline std::vector<edge> plan(std::span<const std::string> sources, options opt
         for (auto const& inc : opt.includes)
             e.command.push_back("-I" + (std::filesystem::path(inc).is_absolute()
                                         ? inc : root + "/" + inc));
+        for (auto const& f : opt.flags) e.command.push_back(f);
         e.command.insert(e.command.end(), { "-c", root + "/" + src, "-o", obj });
         e.inputs  = { root + "/" + src };
         e.outputs = { obj };

rules/hip.cppm

@@ -69,6 +69,17 @@ struct options {
     // the form `mcpp::dep_dir` answers with -- a device compiler is a separate
     // driver and inherits nothing from the C++ side's include configuration.
     std::vector<std::string> includes;
+    // FLAGS FOR THE ISLAND'S COMPILER, PASSED THROUGH UNEXAMINED.
+    //
+    // A device compiler is a separate driver with its own command line, and
+    // `mcpp::cflag`/`mcpp::cxxflag` reach mcpp's compiler rather than this one.
+    // The case this exists for is `mcpp.tools.island`, whose
+    // `force_include_flags` makes the island read its generated boundary header
+    // before its first line -- so the island names no generated file and the
+    // project has no header of its own. Project-wide flags cannot do that job:
+    // forcing a header into every C++ translation unit puts declarations ahead
+    // of `export module`, which no module interface unit accepts.
+    std::vector<std::string> flags;
     std::string out_dir = std::string(mcpp::out_dir());
 };
 
@@ -420,6 +431,7 @@ inline std::vector<edge> plan(std::span<const std::string> sources, options opt
         for (auto const& inc : opt.includes)
             e.command.push_back("-I" + (std::filesystem::path(inc).is_absolute()
                                         ? inc : root + "/" + inc));
+        for (auto const& f : opt.flags) e.command.push_back(f);
         e.command.insert(e.command.end(), { "-c", root + "/" + src, "-o", obj });
         e.inputs  = { root + "/" + src };
         e.outputs = { obj };

rules/sycl.cppm

@@ -98,6 +98,17 @@ struct options {
     // Header search paths for the island. Relative entries resolve against the
     // package root; an ABSOLUTE entry is passed through unchanged.
     std::vector<std::string> includes;
+    // FLAGS FOR THE ISLAND'S COMPILER, PASSED THROUGH UNEXAMINED.
+    //
+    // A device compiler is a separate driver with its own command line, and
+    // `mcpp::cflag`/`mcpp::cxxflag` reach mcpp's compiler rather than this one.
+    // The case this exists for is `mcpp.tools.island`, whose
+    // `force_include_flags` makes the island read its generated boundary header
+    // before its first line -- so the island names no generated file and the
+    // project has no header of its own. Project-wide flags cannot do that job:
+    // forcing a header into every C++ translation unit puts declarations ahead
+    // of `export module`, which no module interface unit accepts.
+    std::vector<std::string> flags;
     // An explicit compiler path wins over the payload. Set it when a project
     // pins a DPC++ other than the one the workspace installed.
     std::string compiler;
@@ -483,6 +494,7 @@ inline std::vector<edge> plan(std::span<const std::string> sources, options opt
         for (auto const& inc : opt.includes)
             e.command.push_back("-I" + (std::filesystem::path(inc).is_absolute()
                                         ? inc : root + "/" + inc));
+        for (auto const& f : opt.flags) e.command.push_back(f);
         // `-x c++` is not optional. `.sycl` is this ecosystem's spelling and
         // no compiler knows it; without this the driver classifies the file as
         // a LINKER INPUT, warns `'linker' input unused`, exits 0 and produces