Scaffold the Before-M1 repo skeleton

Stand up the modular-monolith skeleton per docs/V1_BUILD_PLAN.md: one .NET 10
solution with web + worker hosts sharing seven interface-bounded module projects,
PostgreSQL 17 + pgvector via EF Core 10, a React 19 + Vite SPA built into wwwroot,
and Docker Compose for one-command local dev. Skeleton only — no feature code.

Architecture
- One project per module (OrgBoard, Identity, Skills, Assembler, Governance,
  Memory, Integrations); each is its own assembly so non-public types (entities,
  DbContext) are invisible across modules at compile time.
- TeamUp.Bootstrap is the only library that references all modules; both hosts
  reference only Bootstrap. SharedKernel/Infrastructure never reference modules.
- IModule seam: Register(...) runs in both hosts; MapEndpoints(...) only in web.
- PlatformDbContext owns the pgvector extension + the seven module schemas
  (InitialPlatform migration); MigrationRunner applies it then any module context.
- One image, two roles selected by RUN_MODE at the Docker entrypoint.

Verified
- dotnet build green (nullable + warnings-as-errors).
- ArchitectureTests 8/8 — reflection-based boundary rules (no module -> module,
  -> Infrastructure, -> Bootstrap, or -> host references).
- IntegrationTests 10/10 — Testcontainers boots the host against real pgvector:
  migration applies, vector extension + 7 schemas exist, /health 200, every
  /api/<module>/ping 200, /openapi/v1.json served.
- client builds clean (Vite 6 — pinned for Node 22.3.0; Vite 8 needs Node >=22.12).

Packages and base images route through the Nexus mirror (mirror.soroushasadi.com),
reachable from Iran when nuget.org / Docker Hub / MCR are not. CI is intentionally
deferred to a later session.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

tests/TeamUp.ArchitectureTests/PersistenceEncapsulationTests.cs

@@ -0,0 +1,64 @@
+using Microsoft.EntityFrameworkCore;
+using TeamUp.Bootstrap;
+using TeamUp.Infrastructure.Persistence;
+using TeamUp.SharedKernel.Modularity;
+using Xunit;
+
+namespace TeamUp.ArchitectureTests;
+
+/// <summary>
+/// Guards persistence encapsulation and module shape. A module's DbContext/entities are its
+/// private business — never public — and each module exposes exactly one registration seam.
+/// </summary>
+public sealed class PersistenceEncapsulationTests
+{
+    private static readonly System.Reflection.Assembly[] AllProductionAssemblies =
+    [
+        typeof(IModule).Assembly,
+        typeof(MigrationRunner).Assembly,
+        typeof(ModuleCatalog).Assembly,
+        .. ArchitectureFixture.ModuleAssemblies,
+    ];
+
+    [Fact]
+    public void No_DbContext_is_publicly_visible()
+    {
+        var publicContexts = AllProductionAssemblies
+            .SelectMany(assembly => assembly.GetTypes())
+            .Where(type => typeof(DbContext).IsAssignableFrom(type) && type.IsPublic)
+            .Select(type => type.FullName)
+            .ToList();
+
+        Assert.True(
+            publicContexts.Count == 0,
+            $"A DbContext must be internal to its module. Public contexts found: {string.Join(", ", publicContexts)}");
+    }
+
+    [Fact]
+    public void Each_module_assembly_exposes_exactly_one_IModule()
+    {
+        foreach (var assembly in ArchitectureFixture.ModuleAssemblies)
+        {
+            var implementations = assembly.GetTypes()
+                .Where(type => typeof(IModule).IsAssignableFrom(type)
+                    && type is { IsInterface: false, IsAbstract: false })
+                .ToList();
+
+            Assert.True(
+                implementations.Count == 1,
+                $"{assembly.GetName().Name} must expose exactly one IModule; found {implementations.Count}.");
+        }
+    }
+
+    [Fact]
+    public void ModuleCatalog_lists_every_module_with_a_unique_name()
+    {
+        var modules = ModuleCatalog.All;
+
+        Assert.Equal(ArchitectureFixture.ModuleAssemblies.Length, modules.Count);
+
+        var names = modules.Select(module => module.Name).ToList();
+        Assert.All(names, name => Assert.False(string.IsNullOrWhiteSpace(name)));
+        Assert.Equal(names.Count, names.Distinct(StringComparer.Ordinal).Count());
+    }
+}