refactor: move buildable .NET source into src/, update CI/doc paths

Groups the repo root into src (buildable source), docs (already existed),
and everything else (db/, scripts/, tests/, deploy/ - deployment/ops/test
assets that aren't compiled, already organized as their own folders). CI
now only needs src/ to build: dotnet restore/build/test/publish all point
at src/TaxBaik.sln, src/TaxBaik.Web/, src/TaxBaik.Proxy/.

- git mv every project (Domain, Infrastructure, Application,
  Application.Tests, Web, Web.Client, Proxy) and TaxBaik.sln into src/ as a
  unit, so relative ProjectReference/.sln paths stay valid unchanged.
- .gitea/workflows/deploy.yml: 6 dotnet restore/clean/build/test/publish
  invocations now point at src/. db/migrations and scripts/ stay at root
  (deploy_gb.sh and browser-e2e.yml only touch published output and the
  deployed URL, not source paths - verified, no changes needed there).
- scripts/validate_admin_render.sh: admin render-mode file paths now
  src/TaxBaik.Web.Client/...
- scripts/validate_kst_timestamps.sh: dropped deploy.sh from its target
  list - that script was removed in the prior cleanup commit (dead, no
  CI workflow referenced it) but this validator still expected it to exist.
- CLAUDE.md, docs/ENGINEERING_HARNESS.md, docs/ADMIN_PATTERN_CRITIQUE_WBS.md:
  updated project-structure diagram, dotnet run/build commands, and grep
  targets to the new src/ paths (also fixed a pre-existing stale path in
  ADMIN_PATTERN_CRITIQUE_WBS.md that still said TaxBaik.Web/Components/Admin
  from before that ever moved to TaxBaik.Web.Client).
- Added a Repo Root harness rule + Architecture Guardrail entries: new files
  belong under src/docs/tests/scripts/db/deploy, not loose at root; temp
  work stays outside the repo (or under a gitignored .scratch/) and is
  never committed.

Verified locally: dotnet build/test src/TaxBaik.sln (26/26 tests), and all
three scripts/validate_*.sh pass against the new layout.

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

src/TaxBaik.Application.Tests/BlogServiceTests.cs

@@ -0,0 +1,132 @@
+namespace TaxBaik.Application.Tests;
+
+using TaxBaik.Application.DTOs;
+using TaxBaik.Application.Services;
+using TaxBaik.Domain.Entities;
+using TaxBaik.Domain.Interfaces;
+using Microsoft.Extensions.Caching.Memory;
+using Xunit;
+
+public class BlogServiceTests
+{
+    [Fact]
+    public async Task CreateAsync_WhenPublishedWithoutSeoTitle_ThrowsValidationException()
+    {
+        var service = new BlogService(new FakeBlogPostRepository(), new MemoryCache(new MemoryCacheOptions()));
+
+        await Assert.ThrowsAsync<ValidationException>(() => service.CreateAsync(new CreateBlogPostDto
+        {
+            Title = "테스트 포스트",
+            Content = "본문",
+            SeoDescription = "설명",
+            IsPublished = true
+        }));
+    }
+
+    [Fact]
+    public async Task CreateAsync_WhenTitleDuplicates_GeneratesUniqueSlug()
+    {
+        var repository = new FakeBlogPostRepository
+        {
+            Posts =
+            [
+                new BlogPost { Id = 1, Title = "같은 제목", Content = "본문", Slug = "같은-제목" }
+            ]
+        };
+        var service = new BlogService(repository, new MemoryCache(new MemoryCacheOptions()));
+
+        var post = await service.CreateAsync(new CreateBlogPostDto
+        {
+            Title = "같은 제목",
+            Content = "본문"
+        });
+
+        Assert.Equal("같은-제목-2", post.Slug);
+    }
+
+    [Fact]
+    public async Task DeleteAsync_SoftDeletesPost_AndExcludesFromSlugLookup()
+    {
+        var repository = new FakeBlogPostRepository
+        {
+            Posts =
+            [
+                new BlogPost { Id = 1, Title = "삭제 대상", Content = "본문", Slug = "delete-me", IsPublished = true }
+            ]
+        };
+        var service = new BlogService(repository, new MemoryCache(new MemoryCacheOptions()));
+
+        await service.DeleteAsync(1);
+
+        Assert.NotNull(repository.Posts.Single().DeletedAt);
+        Assert.Null(await service.GetBySlugAsync("delete-me"));
+        Assert.Null(await service.GetByIdAsync(1));
+    }
+
+    private sealed class FakeBlogPostRepository : IBlogPostRepository
+    {
+        public List<BlogPost> Posts { get; init; } = [];
+
+        public Task<BlogPost?> GetByIdAsync(int id, CancellationToken cancellationToken = default) =>
+            Task.FromResult(Posts.FirstOrDefault(x => x.Id == id && x.DeletedAt == null));
+
+        public Task<BlogPost?> GetBySlugAsync(string slug, CancellationToken cancellationToken = default) =>
+            Task.FromResult(Posts.FirstOrDefault(x => x.Slug == slug && x.IsPublished && x.DeletedAt == null));
+
+        public Task<(IEnumerable<BlogPost> Items, int Total)> GetPublishedPagedAsync(
+            int page, int pageSize, int? categoryId = null, CancellationToken cancellationToken = default)
+        {
+            var items = Posts.Where(x => x.IsPublished).ToList();
+            return Task.FromResult<(IEnumerable<BlogPost>, int)>((items, items.Count));
+        }
+
+        public Task<IEnumerable<BlogPost>> GetByCategorySlugAsync(string categorySlug, int limit, CancellationToken cancellationToken = default) =>
+            Task.FromResult<IEnumerable<BlogPost>>(Posts.Where(x => x.IsPublished).Take(limit).ToList());
+
+        public Task<IEnumerable<BlogPost>> GetAllForAdminAsync(CancellationToken cancellationToken = default) =>
+            Task.FromResult<IEnumerable<BlogPost>>(Posts);
+
+        public Task<(IEnumerable<BlogPost> Items, int Total)> GetAdminPagedAsync(
+            int page, int pageSize, CancellationToken cancellationToken = default)
+        {
+            var items = Posts.ToList();
+            return Task.FromResult<(IEnumerable<BlogPost>, int)>((items, items.Count));
+        }
+
+        public Task<(IEnumerable<BlogPost> Items, int Total)> GetArchivedPagedAsync(
+            int page, int pageSize, CancellationToken cancellationToken = default)
+        {
+            var items = Posts.Where(x => x.DeletedAt != null).ToList();
+            return Task.FromResult<(IEnumerable<BlogPost>, int)>((items, items.Count));
+        }
+
+        public Task<int> CreateAsync(BlogPost post, CancellationToken cancellationToken = default)
+        {
+            post.Id = Posts.Count + 1;
+            Posts.Add(post);
+            return Task.FromResult(post.Id);
+        }
+
+        public Task UpdateAsync(BlogPost post, CancellationToken cancellationToken = default) => Task.CompletedTask;
+
+        public Task DeleteAsync(int id, CancellationToken cancellationToken = default)
+        {
+            var post = Posts.FirstOrDefault(x => x.Id == id);
+            if (post != null)
+                post.DeletedAt = DateTime.UtcNow;
+            return Task.CompletedTask;
+        }
+
+        public Task ArchiveAsync(int id, CancellationToken cancellationToken = default) => DeleteAsync(id, cancellationToken);
+
+        public Task RestoreAsync(int id, CancellationToken cancellationToken = default)
+        {
+            var post = Posts.FirstOrDefault(x => x.Id == id);
+            if (post != null)
+                post.DeletedAt = null;
+            return Task.CompletedTask;
+        }
+
+        public Task IncrementViewCountAsync(int id, CancellationToken cancellationToken = default) => Task.CompletedTask;
+    }
+}