feat: accept Filtered.Types selections as dependency targets for architecture rules

A reusable Filtered.Types selection (a "layer") can now act as a dependency
target alongside the namespace and specific-type forms:

- ThatType: DependsOn / DoesNotDependOn / DependsOnlyOn(Filtered.Types target,
  params Filtered.Types[] additional)
- ThatTypes: DependOn / DoNotDependOn / DependOnlyOn (IEnumerable and
  IAsyncEnumerable subjects)
- TypeFilters: WhichDependOn / WhichDoNotDependOn / WhichDependOnlyOn
- All results and the filter result chain with OrOn(params Filtered.Types[])
  to widen the targeted/allowed selections (Or is the inherited
  AndOrResult property and must not be hidden).

Each target selection is resolved once per assertion into the union set;
membership is by type identity, with a generic type definition in the set
matching any of its constructions. The only-on family keeps the own-namespace
allowance and the framework rule, so an empty selection allows exactly the
own namespace and framework dependencies. All dependency resolution still
goes through TypeHelpers.ResolveDependencies, so a customized resolver
applies automatically.

The first target is a regular parameter instead of params, because a pure
params Filtered.Types[] overload would make the existing zero-argument
calls (e.g. DependsOn()) ambiguous with the params IEnumerable<string>
namespace overloads (CS0121); this also enforces "at least one target" at
compile time.

The README gains an "Architecture rules" section documenting the pattern:
layers as reusable selections, combining rules with Expect.ThatAll, the
aggregated failure shape, and exemptions via the Except filter.

Author: vbreuss

README.md

@@ -492,6 +492,9 @@ await Expect.That(Types.InNamespace("MyApp.Domain"))
 await Expect.That(typeof(MyDomainType)).DoesNotDependOn<DbContext>().OrOn<SqlConnection>();
 ```
 
+All three dependency families additionally accept a reusable `Filtered.Types` selection as target — see
+[Architecture rules](#architecture-rules).
+
 > **Framework dependencies are ignored unless you name one explicitly.** `DependOnlyOn` ignores dependencies
 > whose assembly name matches one of the
 > [`ExcludedAssemblyPrefixes`](#assembly-exclusions) at a name-segment boundary: `System` covers `System`
@@ -554,6 +557,79 @@ Because the edges come from the same dependency resolution as the other dependen
 [custom dependency resolver](#dependency-resolver) (e.g. an IL-level one) also sharpens cycle
 detection: body-level references it surfaces can complete a cycle that the signature-level default cannot see.
 
+### Architecture rules
+
+There is no separate rule engine: a "layer" is just a reusable `Filtered.Types` selection (with the full
+filter vocabulary at your disposal), and an architecture rule is just an expectation on it.
+
+```csharp
+Filtered.Types domain         = Types.InNamespace("MyApp.Domain");
+Filtered.Types infrastructure = Types.InNamespace("MyApp.Infrastructure");
+Filtered.Types repositories   = Types.InNamespace("MyApp.Data").WithName("Repository").AsSuffix();
+```
+
+The dependency assertions and filters accept such a selection as a **target**, alongside the namespace and
+specific-type forms: `DependsOn` / `DoesNotDependOn` / `DependsOnlyOn` (and the plural `DependOn` /
+`DoNotDependOn` / `DependOnlyOn` and the `WhichDependOn` / `WhichDoNotDependOn` / `WhichDependOnlyOn`
+filters) take one or more `Filtered.Types` arguments. Each target selection is resolved once per assertion;
+a dependency matches when it is a member of the union of the resolved selections — by type identity, where a
+generic type definition in the selection (e.g. a scanned `Repository<>`) matches any of its constructions.
+Multiple targets and `.OrOn(…)` mean *any of*; for the *only-on* family the union is the allowed set, while
+the own-namespace and framework rules apply unchanged (an empty selection thus allows only the own namespace
+and framework dependencies). A selection is an explicit target, so framework types contained in it are
+matched normally by `DependsOn` / `DoesNotDependOn`.
+
+```csharp
+// Outgoing rule with a selection as target:
+await Expect.That(domain).DoNotDependOn(infrastructure);
+
+// Incoming rules are written explicitly from the other side:
+await Expect.That(infrastructure).DoNotDependOn(domain);
+
+// Allowed set as union of selections (own namespace + framework stay allowed):
+await Expect.That(domain).DependOnlyOn(repositories).OrOn(infrastructure);
+```
+
+Combine several rules into a single verification with aweXpect's `Expect.ThatAll(…)` (see
+[multiple expectations](https://docs.testably.org/aweXpect/advanced/multiple-expectations)) — every rule is
+evaluated and all failures are reported together. Any assertion works on a selection, not just the
+dependency ones, so naming conventions or sealing rules live in the same check:
+
+```csharp
+await Expect.ThatAll(
+    Expect.That(domain).DoNotDependOn(infrastructure),
+    Expect.That(domain).DependOnlyOn(repositories).OrOn(infrastructure),
+    Expect.That(domain).AreSealed());
+```
+
+A failing rule reports all violations, numbered per expectation:
+
+```
+Expected all of the following to succeed:
+ [01] Expected that domain all do not depend on types within namespace "MyApp.Infrastructure" in all loaded assemblies
+ [02] Expected that domain are all sealed
+but
+ [01] it contained types with the dependency [
+  OrderService
+]
+ [02] it contained non-sealed types [
+  Order,
+  Invoice
+]
+```
+
+Exemptions to a rule use the [`Except` filter](#filters-and-the-matching-assertions) on the subject
+selection:
+
+```csharp
+await Expect.That(domain.Except<LegacyService>()).DoNotDependOn(infrastructure);
+await Expect.That(domain.Except(type => type.Name.StartsWith("Generated"))).AreSealed();
+```
+
+A layer spanning several namespaces is built by widening a dependency *target* with additional selections
+(or `.OrOn(…)`); for a *subject* spanning several namespaces, assert each namespace selection as its own
+rule inside the same `Expect.ThatAll(…)`.
+
 ### Methods
 
 In addition to [access modifiers](#access-modifiers),

Source/aweXpect.Reflection/Collections/Filtered.Types.cs

@@ -543,5 +543,39 @@ public Types InEntryAssembly()
 			public Types InExecutingAssembly()
 				=> In.ExecutingAssembly().Types().WithinNamespace(_namespace);
 		}
+
+		/// <summary>
+		///     A filtered collection of <see cref="System.Type" /> from a dependency filter whose targets are filtered
+		///     collections of types, allowing to widen the targeted/allowed collections.
+		/// </summary>
+		/// <remarks>
+		///     Like all filtered collections, this is an immutable value object: <see cref="OrOn" /> does not mutate
+		///     this instance but rebuilds a fresh filter from the original base collection, so deriving multiple views
+		///     from the same instance cannot corrupt each other.
+		/// </remarks>
+		public sealed class TypeSetDependencyFilterResult : Types
+		{
+			private readonly Func<TypeSetDependencyOptions, Types> _build;
+			private readonly TypeSetDependencyOptions _options;
+
+			internal TypeSetDependencyFilterResult(
+				TypeSetDependencyOptions options,
+				Func<TypeSetDependencyOptions, Types> build)
+				: base(build(options))
+			{
+				_options = options;
+				_build = build;
+			}
+
+			/// <summary>
+			///     Widens the filter by the given <paramref name="targets" />.
+			/// </summary>
+			public TypeSetDependencyFilterResult OrOn(params Filtered.Types[] targets)
+			{
+				TypeSetDependencyOptions widened = _options.Copy();
+				widened.OrOn(targets);
+				return new TypeSetDependencyFilterResult(widened, _build);
+			}
+		}
 	}
 }

Source/aweXpect.Reflection/Filters/TypeFilters.WhichDependOn.cs

@@ -28,4 +28,44 @@ public static Filtered.Types.NamespaceDependencyFilterResult WhichDoNotDependOn(
 			options => @this.Which(Filter.Suffix<Type>(
 				type => !options.IsMatchedBy(type),
 				() => $"which do not depend on {options.Describe()} ")));
+
+	/// <summary>
+	///     Filter for types which depend on (reference in their signature) at least one type in the filtered
+	///     collections of types <paramref name="target" /> or <paramref name="additional" />.
+	/// </summary>
+	/// <remarks>
+	///     The target collections are resolved once per filter; a dependency matches when it is a member of the
+	///     union of the resolved collections (by <see cref="Type" /> identity; a generic type definition in a
+	///     collection matches any construction of it).
+	/// </remarks>
+	public static Filtered.Types.TypeSetDependencyFilterResult WhichDependOn(
+		this Filtered.Types @this, Filtered.Types target, params Filtered.Types[] additional)
+		=> new(new TypeSetDependencyOptions(target, additional),
+			options => @this.Which(Filter.Suffix<Type>(
+				async type =>
+				{
+					await options.Resolve();
+					return options.IsMatchedBy(type);
+				},
+				() => $"which depend on {options.Describe()} ")));
+
+	/// <summary>
+	///     Filter for types which do not depend on (do not reference in their signature) any type in the filtered
+	///     collections of types <paramref name="target" /> or <paramref name="additional" />.
+	/// </summary>
+	/// <remarks>
+	///     The target collections are resolved once per filter; a dependency matches when it is a member of the
+	///     union of the resolved collections (by <see cref="Type" /> identity; a generic type definition in a
+	///     collection matches any construction of it).
+	/// </remarks>
+	public static Filtered.Types.TypeSetDependencyFilterResult WhichDoNotDependOn(
+		this Filtered.Types @this, Filtered.Types target, params Filtered.Types[] additional)
+		=> new(new TypeSetDependencyOptions(target, additional),
+			options => @this.Which(Filter.Suffix<Type>(
+				async type =>
+				{
+					await options.Resolve();
+					return !options.IsMatchedBy(type);
+				},
+				() => $"which do not depend on {options.Describe()} ")));
 }

Source/aweXpect.Reflection/Filters/TypeFilters.WhichDependOnlyOn.cs

@@ -28,4 +28,33 @@ public static Filtered.Types.NamespaceDependencyOnlyOnFilterResult WhichDependOn
 			options => @this.Which(Filter.Suffix<Type>(
 				type => !type.HasDependencyNamespaceViolations(options),
 				() => $"which depend only on {options.Describe()} ")));
+
+	/// <summary>
+	///     Filter for types which depend on (reference in their signature) only types in the filtered collections
+	///     of types <paramref name="target" /> or <paramref name="additional" />, their own namespace or framework
+	///     assemblies.
+	/// </summary>
+	/// <remarks>
+	///     The target collections are resolved once per filter; a dependency is allowed when it is a member of the
+	///     union of the resolved collections (by <see cref="Type" /> identity; a generic type definition in a
+	///     collection matches any construction of it).
+	///     <para />
+	///     Dependencies on types whose assembly name matches one of the
+	///     <see cref="AwexpectCustomization.ReflectionCustomizationValue.ExcludedAssemblyPrefixes" /> at a
+	///     name-segment boundary (<c>System</c> covers <c>System.Text.Json</c>, but not
+	///     <c>SystemsBiology.Core</c>) are ignored, so
+	///     that framework types do not have to be included explicitly. The default prefixes include
+	///     <c>Microsoft</c>, so e.g. <c>Microsoft.EntityFrameworkCore</c> is also ignored; forbid such a dependency
+	///     explicitly via <c>WhichDoNotDependOn</c> or customize the prefixes.
+	/// </remarks>
+	public static Filtered.Types.TypeSetDependencyFilterResult WhichDependOnlyOn(
+		this Filtered.Types @this, Filtered.Types target, params Filtered.Types[] additional)
+		=> new(new TypeSetDependencyOptions(target, additional),
+			options => @this.Which(Filter.Suffix<Type>(
+				async type =>
+				{
+					await options.Resolve();
+					return !type.HasDependencyTypeSetViolations(options);
+				},
+				() => $"which depend only on {options.Describe()} ")));
 }

Source/aweXpect.Reflection/Helpers/TypeHelpers.cs

@@ -933,6 +933,68 @@ private static bool IsOwnNamespace(string? dependencyNamespace, string? ownNames
 			? dependencyNamespace is null
 			: NamespaceMatches(dependencyNamespace, ownNamespace, includeSubNamespaces);
 
+	/// <summary>
+	///     Collects the <paramref name="type" />'s dependencies that are not allowed by the resolved target set in
+	///     <paramref name="allowed" />, the type's own namespace, or the framework rule.
+	/// </summary>
+	/// <remarks>
+	///     Same framework and own-namespace rules as <see cref="GetDependencyNamespaceViolations" />, but the allowed
+	///     set is a concrete set of types, so the violations are reported as formatted type names instead of
+	///     namespaces. Requires <see cref="TypeSetDependencyOptions.Resolve" /> to have been awaited before.
+	/// </remarks>
+	internal static IReadOnlyList<string> GetDependencyTypeSetViolations(
+		this Type type, TypeSetDependencyOptions allowed)
+	{
+		string? ownNamespace = type.Namespace;
+		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
+		List<string> violations = [];
+		HashSet<string> seen = new(StringComparer.Ordinal);
+		foreach (Type dependency in type.ResolveDependencies())
+		{
+			if (!IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes))
+			{
+				continue;
+			}
+
+			string display = Formatter.Format(dependency);
+			if (seen.Add(display))
+			{
+				violations.Add(display);
+			}
+		}
+
+		violations.Sort(StringComparer.Ordinal);
+		return violations;
+	}
+
+	/// <summary>
+	///     Checks whether the <paramref name="type" /> has at least one dependency outside the resolved target set,
+	///     stopping at the first one.
+	/// </summary>
+	/// <remarks>
+	///     Same rules as <see cref="GetDependencyTypeSetViolations" />, for callers (like filters) that only need
+	///     a verdict and not the violation list.
+	/// </remarks>
+	internal static bool HasDependencyTypeSetViolations(this Type type, TypeSetDependencyOptions allowed)
+	{
+		string? ownNamespace = type.Namespace;
+		string[] excludedPrefixes = Customize.aweXpect.Reflection().ExcludedAssemblyPrefixes.Get();
+		return type.ResolveDependencies()
+			.Any(dependency => IsDependencyTypeSetViolation(dependency, ownNamespace, allowed, excludedPrefixes));
+	}
+
+	private static bool IsDependencyTypeSetViolation(
+		Type dependency, string? ownNamespace, TypeSetDependencyOptions allowed, string[] excludedPrefixes)
+	{
+		if (dependency.IsFrameworkDependency(excludedPrefixes))
+		{
+			return false;
+		}
+
+		return !IsOwnNamespace(dependency.Namespace, ownNamespace, true) &&
+		       !allowed.Matches(dependency);
+	}
+
 	/// <summary>
 	///     Resolves the dependencies of the <paramref name="type" /> through which all assertions and filters go,
 	///     using the resolver configured via the <c>DependencyResolver</c> customization