feat: Setup CI/CD infrastructure with Go, Frontend, and Docker workflows (#22)

## Summary

This PR sets up the complete CI/CD infrastructure for the Chat Switchboard project, implementing automated testing, linting, building, and Docker containerization.

## Changes

### CI/CD Workflows

1. **`.gitea/workflows/backend.yml`** - Backend CI pipeline
   - Automated Go module initialization
   - Test execution with coverage reporting
   - Code linting with golangci-lint
   - Binary compilation with version tags
   - Artifact upload for debugging

2. **`.gitea/workflows/frontend.yml`** - Frontend CI pipeline
   - JavaScript linting with ESLint
   - CSS validation with Prettier
   - Standalone HTML build via build.sh
   - HTML structure validation
   - Build artifact management

3. **`.gitea/workflows/docker.yml`** - Docker CI pipeline
   - Backend container building and testing
   - Frontend container building
   - Automatic image tagging on tags/branches
   - Registry push on main branch
   - Multi-arch manifest creation

### Docker Configuration

- `server/Dockerfile` - Multi-stage Go backend container with health checks
- `Dockerfile.frontend` - Nginx frontend container with gzip compression
- `nginx.conf` - Optimized nginx config with security headers

### Dependencies

- `server/go.mod` - Initialized Go module with Gin and godotenv

### Documentation

- `docs/CICD_SETUP.md` - Comprehensive CI/CD documentation

## Features

- ✅ Auto-trigger on push/PR to main/develop
- ✅ Test coverage reporting
- ✅ Code quality checks (golangci-lint, ESLint)
- ✅ Build artifact management (7-day retention)
- ✅ Semantic versioning support (v* tags)
- ✅ Multi-stage Docker builds
- ✅ Container health checks
- ✅ Security headers in nginx
- ✅ Gzip compression
- ✅ Non-root container execution

## Testing

The workflows will automatically run on this PR. Once merged, all future PRs and pushes to main/develop will trigger the appropriate CI checks.

## Acceptance Criteria

- ✅ All PRs run CI checks
- ✅ Docker images auto-build on tags
- ✅ Standalone build generates on each commit

## Next Steps (Manual)

1. Merge this PR to `main`
2. Create `develop` branch: `git checkout main && git checkout -b develop && git push origin develop`
3. Configure branch protection in Gitea (Settings → Branches → Add protection rule for main/develop)
4. Test with a sample PR to verify CI runs

## Breaking Changes

None. This is purely infrastructure setup with no impact on existing functionality.

Reviewed-on: xcaliber/chat-switchboard#22

server/main_test.go

@@ -0,0 +1,96 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+)
+
+func TestHealthEndpoint(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	r := gin.New()
+	r.GET("/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{"status": "ok"})
+	})
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("GET", "/health", nil)
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusOK {
+		t.Errorf("Expected status %d, got %d", http.StatusOK, w.Code)
+	}
+
+	expectedBody := `{"status":"ok"}`
+	if w.Body.String() != expectedBody {
+		t.Errorf("Expected body %s, got %s", expectedBody, w.Body.String())
+	}
+}
+
+func TestCORSHeaders(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	r := gin.New()
+	r.Use(func(c *gin.Context) {
+		c.Header("Access-Control-Allow-Origin", "*")
+		c.Header("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS")
+		c.Header("Access-Control-Allow-Headers", "Content-Type, Authorization")
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+		c.Next()
+	})
+
+	w := httptest.NewRecorder()
+	req, _ := http.NewRequest("OPTIONS", "/api/v1/test", nil)
+	r.ServeHTTP(w, req)
+
+	if w.Code != http.StatusNoContent {
+		t.Errorf("Expected status %d for OPTIONS, got %d", http.StatusNoContent, w.Code)
+	}
+
+	if w.Header().Get("Access-Control-Allow-Origin") != "*" {
+		t.Error("Missing or incorrect CORS header")
+	}
+}
+
+func TestRouterSetup(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+	r := gin.New()
+
+	// Setup routes like in main.go
+	r.GET("/health", func(c *gin.Context) {
+		c.JSON(200, gin.H{"status": "ok"})
+	})
+
+	api := r.Group("/api/v1")
+	{
+		api.POST("/auth/register", handleRegister)
+		api.POST("/auth/login", handleLogin)
+		api.GET("/chats", handleListChats)
+		api.POST("/chats", handleCreateChat)
+	}
+
+	// Verify routes are registered
+	routes := r.Routes()
+	routePaths := make(map[string]bool)
+	for _, route := range routes {
+		routePaths[route.Method+" "+route.Path] = true
+	}
+
+	expectedRoutes := []string{
+		"GET /health",
+		"POST /api/v1/auth/register",
+		"POST /api/v1/auth/login",
+		"GET /api/v1/chats",
+		"POST /api/v1/chats",
+	}
+
+	for _, expected := range expectedRoutes {
+		if !routePaths[expected] {
+			t.Errorf("Expected route %s to be registered", expected)
+		}
+	}
+}