feat: implement all P1/P2/P3/P4 improvements from issue backlog

P1 correctness:
- filter test files by default (--include-tests to opt in)
- per-module diagrams show cross-module dependency arrows
- qualified type names (Module::TypeName) fix false edges from duplicate names

P2 output richness:
- method parameter types and return types in class diagrams (Rust + Python)
- Python pyproject.toml project analyzer (--level project for monorepos)

P3 unique value:
- boundary rules in archlens.toml ([rules] allow/deny, --strict enforcement)

P4 nice to have:
- dependency weight labels on module arrows (--no-weights to disable)
- --watch mode with 500ms debounce
- D2 renderer adapter (--format d2)
- interactive self-contained HTML viewer (--format html)
- git-aware incremental analysis (--since <ref>)

crates/domain/tests/code_graph_tests.rs

@@ -115,6 +115,180 @@ fn subgraph_of_nonexistent_module_is_empty() {
     assert!(subgraph.relationships().is_empty());
 }
 
+#[test]
+fn qualify_sets_qualified_name_on_elements_with_modules() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("DtoBaseModel", Some("Commons")));
+    graph.add_element(make_element("DtoBaseModel", Some("Api")));
+    graph.add_element(make_element("Orphan", None));
+
+    let graph = graph.qualify();
+
+    let commons_dto = graph
+        .elements()
+        .iter()
+        .find(|e| e.module().map(|m| m.as_str()) == Some("Commons"))
+        .unwrap();
+    assert_eq!(commons_dto.qualified_name(), "Commons::DtoBaseModel");
+
+    let api_dto = graph
+        .elements()
+        .iter()
+        .find(|e| e.module().map(|m| m.as_str()) == Some("Api"))
+        .unwrap();
+    assert_eq!(api_dto.qualified_name(), "Api::DtoBaseModel");
+
+    let orphan = graph
+        .elements()
+        .iter()
+        .find(|e| e.name() == "Orphan")
+        .unwrap();
+    assert_eq!(orphan.qualified_name(), "Orphan");
+}
+
+#[test]
+fn qualify_rewrites_unambiguous_relationship_target() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("OrderService", Some("App")));
+    graph.add_element(make_element("Order", Some("Domain")));
+    graph.add_relationship(
+        Relationship::new("OrderService", "Order", RelationshipKind::Composition).unwrap(),
+    );
+
+    let graph = graph.qualify();
+
+    let rel = &graph.relationships()[0];
+    assert_eq!(rel.source(), "App::OrderService");
+    assert_eq!(rel.target(), "Domain::Order");
+}
+
+#[test]
+fn qualify_disambiguates_target_by_source_module() {
+    let mut graph = CodeGraph::new();
+    // DtoBaseModel exists in both Commons and Api
+    graph.add_element(make_element("DtoBaseModel", Some("Commons")));
+    graph.add_element(make_element("DtoBaseModel", Some("Api")));
+    // GlobalAudienceDefinition inherits DtoBaseModel, and is in Commons
+    graph.add_element(make_element("GlobalAudienceDefinition", Some("Commons")));
+
+    let mut rel = Relationship::new(
+        "GlobalAudienceDefinition",
+        "DtoBaseModel",
+        RelationshipKind::Inheritance,
+    )
+    .unwrap();
+    // source_file is in the Commons module path
+    rel = rel.with_source_file(
+        archlens_domain::FilePath::new("src/commons/global_audience.rs").unwrap(),
+    );
+    // Make GlobalAudienceDefinition's element file match
+    let mut gad = make_element("GlobalAudienceDefinition", Some("Commons"));
+    // rebuild with matching file_path
+    gad = CodeElement::new(
+        "GlobalAudienceDefinition",
+        archlens_domain::CodeElementKind::Class,
+        archlens_domain::FilePath::new("src/commons/global_audience.rs").unwrap(),
+        1,
+    )
+    .unwrap()
+    .with_module(archlens_domain::ModuleName::new("Commons").unwrap());
+
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("DtoBaseModel", Some("Commons")));
+    graph.add_element(make_element("DtoBaseModel", Some("Api")));
+    graph.add_element(gad);
+    graph.add_relationship(rel);
+
+    let graph = graph.qualify();
+
+    let rel = &graph.relationships()[0];
+    assert_eq!(rel.source(), "Commons::GlobalAudienceDefinition");
+    assert_eq!(rel.target(), "Commons::DtoBaseModel");
+}
+
+#[test]
+fn resolve_preserves_relationship_when_both_qualified_names_exist() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("GlobalAudienceDefinition", Some("Commons")));
+    graph.add_element(make_element("DtoBaseModel", Some("Commons")));
+    graph.add_element(make_element("DtoBaseModel", Some("Api")));
+
+    graph.add_relationship(
+        Relationship::new(
+            "GlobalAudienceDefinition",
+            "DtoBaseModel",
+            RelationshipKind::Inheritance,
+        )
+        .unwrap(),
+    );
+
+    let graph = graph.qualify().resolve_relationships();
+
+    // The relationship should survive — Commons::GlobalAudienceDefinition --> Commons::DtoBaseModel
+    assert_eq!(graph.relationships().len(), 1);
+    assert_eq!(
+        graph.relationships()[0].source(),
+        "Commons::GlobalAudienceDefinition"
+    );
+    assert_eq!(graph.relationships()[0].target(), "Commons::DtoBaseModel");
+}
+
+#[test]
+fn cross_module_deps_for_returns_target_module_with_count() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("WidgetJobData", Some("aiss_worker")));
+    graph.add_element(make_element("WidgetType", Some("commons")));
+
+    graph.add_relationship(
+        Relationship::new("WidgetJobData", "WidgetType", RelationshipKind::Composition).unwrap(),
+    );
+
+    let module = ModuleName::new("aiss_worker").unwrap();
+    let deps = graph.cross_module_deps_for(&module);
+
+    assert_eq!(deps.len(), 1);
+    assert_eq!(deps[0].0.as_str(), "commons");
+    assert_eq!(deps[0].1, 1);
+}
+
+#[test]
+fn cross_module_deps_for_returns_empty_for_intra_module_only() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("OrderService", Some("Orders")));
+    graph.add_element(make_element("Order", Some("Orders")));
+    graph.add_relationship(
+        Relationship::new("OrderService", "Order", RelationshipKind::Composition).unwrap(),
+    );
+
+    let module = ModuleName::new("Orders").unwrap();
+    let deps = graph.cross_module_deps_for(&module);
+
+    assert!(deps.is_empty());
+}
+
+#[test]
+fn cross_module_deps_for_aggregates_multiple_relationships_to_same_module() {
+    let mut graph = CodeGraph::new();
+    graph.add_element(make_element("ServiceA", Some("app")));
+    graph.add_element(make_element("ServiceB", Some("app")));
+    graph.add_element(make_element("DomainType1", Some("domain")));
+    graph.add_element(make_element("DomainType2", Some("domain")));
+
+    graph.add_relationship(
+        Relationship::new("ServiceA", "DomainType1", RelationshipKind::Composition).unwrap(),
+    );
+    graph.add_relationship(
+        Relationship::new("ServiceB", "DomainType2", RelationshipKind::Composition).unwrap(),
+    );
+
+    let module = ModuleName::new("app").unwrap();
+    let deps = graph.cross_module_deps_for(&module);
+
+    assert_eq!(deps.len(), 1);
+    assert_eq!(deps[0].0.as_str(), "domain");
+    assert_eq!(deps[0].1, 2);
+}
+
 #[test]
 fn graph_lists_unique_modules() {
     let mut graph = CodeGraph::new();