feat: add monitoring template support to generator

- Add scene_kind field to GenerateSceneRequest
- Update generate_scene_package to use analyze_scene_source_with_hint
- Implement scene_toml_monitoring for simplified monitoring scene manifests
- Add scene_toml router to dispatch to different templates based on SceneKind
- Add --scene-kind CLI option to sg_scene_generate binary
- Add generator_emits_monitoring_template test
- Create monitoring fixture with index.html (no meta tag, tests hint param)

Monitoring templates have simplified scene.toml without org/period resolvers.

🤖 Generated with [Qoder][https://qoder.com]

src/bin/sg_scene_generate.rs

@@ -0,0 +1,93 @@
+use std::env;
+use std::path::PathBuf;
+
+use sgclaw::generated_scene::analyzer::SceneKind;
+use sgclaw::generated_scene::generator::{generate_scene_package, GenerateSceneRequest};
+
+fn main() {
+    if let Err(err) = run() {
+        eprintln!("sg_scene_generate: {err}");
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<(), String> {
+    let args = parse_args(env::args().skip(1))?;
+    let skill_root = generate_scene_package(GenerateSceneRequest {
+        source_dir: args.source_dir,
+        scene_id: args.scene_id,
+        scene_name: args.scene_name,
+        scene_kind: args.scene_kind,
+        output_root: args.output_root,
+        lessons_path: args.lessons_path,
+    })
+    .map_err(|err| err.to_string())?;
+
+    println!("generated scene package: {}", skill_root.display());
+    Ok(())
+}
+
+struct CliArgs {
+    source_dir: PathBuf,
+    scene_id: String,
+    scene_name: String,
+    scene_kind: Option<SceneKind>,
+    output_root: PathBuf,
+    lessons_path: PathBuf,
+}
+
+fn parse_args(args: impl Iterator<Item = String>) -> Result<CliArgs, String> {
+    let mut source_dir = None;
+    let mut scene_id = None;
+    let mut scene_name = None;
+    let mut scene_kind = None;
+    let mut output_root = None;
+    let mut lessons_path = None;
+    let mut pending_flag: Option<String> = None;
+
+    for arg in args {
+        if let Some(flag) = pending_flag.take() {
+            match flag.as_str() {
+                "--source-dir" => source_dir = Some(PathBuf::from(arg)),
+                "--scene-id" => scene_id = Some(arg),
+                "--scene-name" => scene_name = Some(arg),
+                "--scene-kind" => {
+                    scene_kind = Some(
+                        SceneKind::from_str(&arg)
+                            .ok_or_else(|| format!("invalid scene kind: {}", arg))?,
+                    );
+                }
+                "--output-root" => output_root = Some(PathBuf::from(arg)),
+                "--lessons" => lessons_path = Some(PathBuf::from(arg)),
+                _ => return Err(format!("unsupported argument {flag}")),
+            }
+            continue;
+        }
+
+        match arg.as_str() {
+            "--source-dir" | "--scene-id" | "--scene-name" | "--scene-kind" | "--output-root"
+            | "--lessons" => {
+                pending_flag = Some(arg);
+            }
+            "--help" | "-h" => return Err(usage()),
+            _ => return Err(format!("unsupported argument {arg}\n{}", usage())),
+        }
+    }
+
+    if let Some(flag) = pending_flag {
+        return Err(format!("missing value for {flag}"));
+    }
+
+    Ok(CliArgs {
+        source_dir: source_dir.ok_or_else(usage)?,
+        scene_id: scene_id.ok_or_else(usage)?,
+        scene_name: scene_name.ok_or_else(usage)?,
+        scene_kind,
+        output_root: output_root.ok_or_else(usage)?,
+        lessons_path: lessons_path.ok_or_else(usage)?,
+    })
+}
+
+fn usage() -> String {
+    "usage: sg_scene_generate --source-dir <scenario-dir> --scene-id <scene-id> --scene-name <display-name> [--scene-kind <report_collection|monitoring>] --output-root <skill-staging-root> --lessons <lessons-toml>".to_string()
+}