Migrate from Gin to Echo framework and add comprehensive integration tests

Major changes:
- Migrate all handlers from Gin to Echo framework
- Add new apperrors, echohelpers, and validator packages
- Update middleware for Echo compatibility
- Add ArchivedHandler to task categorization chain (archived tasks go to cancelled_tasks column)
- Add 6 new integration tests:
  - RecurringTaskLifecycle: NextDueDate advancement for weekly/monthly tasks
  - MultiUserSharing: Complex sharing with user removal
  - TaskStateTransitions: All state transitions and kanban column changes
  - DateBoundaryEdgeCases: Threshold boundary testing
  - CascadeOperations: Residence deletion cascade effects
  - MultiUserOperations: Shared residence collaboration
- Add single-purpose repository functions for kanban columns (GetOverdueTasks, GetDueSoonTasks, etc.)
- Fix RemoveUser route param mismatch (userId -> user_id)
- Fix determineExpectedColumn helper to correctly prioritize in_progress over overdue

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

internal/models/task.go

@@ -109,14 +109,21 @@ func (Task) TableName() string {
 // single source of truth for task logic. It uses EffectiveDate (NextDueDate ?? DueDate)
 // rather than just DueDate, ensuring consistency with kanban categorization.
 //
+// Uses day-based comparison: a task due TODAY is NOT overdue, it only becomes
+// overdue the NEXT day.
+//
 // Deprecated: Prefer using task.IsOverdue(t, time.Now().UTC()) directly for explicit time control.
 func (t *Task) IsOverdue() bool {
-	// Delegate to predicates package - single source of truth
-	// Import is avoided here to prevent circular dependency.
+	return t.IsOverdueAt(time.Now().UTC())
+}
+
+// IsOverdueAt returns true if the task would be overdue at the given time.
+// Uses day-based comparison: a task due on the same day as `now` is NOT overdue.
+func (t *Task) IsOverdueAt(now time.Time) bool {
 	// Logic must match predicates.IsOverdue exactly:
 	// - Check active (not cancelled, not archived)
 	// - Check not completed (NextDueDate != nil || no completions)
-	// - Check effective date < now
+	// - Check effective date < start of today
 	if t.IsCancelled || t.IsArchived {
 		return false
 	}
@@ -134,7 +141,9 @@ func (t *Task) IsOverdue() bool {
 	if effectiveDate == nil {
 		return false
 	}
-	return effectiveDate.Before(time.Now().UTC())
+	// Day-based comparison: compare against start of today
+	startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	return effectiveDate.Before(startOfDay)
 }
 
 // IsDueSoon returns true if the task is due within the specified days.
@@ -169,6 +178,88 @@ func (t *Task) IsDueSoon(days int) bool {
 	return !effectiveDate.Before(now) && effectiveDate.Before(threshold)
 }
 
+// GetKanbanColumn returns the kanban column name for this task using the
+// Chain of Responsibility pattern from the categorization package.
+// Uses UTC time for categorization.
+//
+// For timezone-aware categorization, use GetKanbanColumnWithTimezone.
+func (t *Task) GetKanbanColumn(daysThreshold int) string {
+	// Import would cause circular dependency, so we inline the logic
+	// This delegates to the categorization package via internal/task re-export
+	return t.GetKanbanColumnWithTimezone(daysThreshold, time.Now().UTC())
+}
+
+// GetKanbanColumnWithTimezone returns the kanban column name using a specific
+// time (in the user's timezone). The time is used to determine "today" for
+// overdue/due-soon calculations.
+//
+// Example: For a user in Tokyo, pass time.Now().In(tokyoLocation) to get
+// accurate categorization relative to their local date.
+func (t *Task) GetKanbanColumnWithTimezone(daysThreshold int, now time.Time) string {
+	// Note: We can't import categorization directly due to circular dependency.
+	// Instead, this method implements the categorization logic inline.
+	// The logic MUST match categorization.Chain exactly.
+
+	if daysThreshold <= 0 {
+		daysThreshold = 30
+	}
+
+	// Start of day normalization
+	startOfDay := time.Date(now.Year(), now.Month(), now.Day(), 0, 0, 0, 0, now.Location())
+	threshold := startOfDay.AddDate(0, 0, daysThreshold)
+
+	// Priority 1: Cancelled
+	if t.IsCancelled {
+		return "cancelled_tasks"
+	}
+
+	// Priority 2: Archived (goes to cancelled column - both are "inactive" states)
+	if t.IsArchived {
+		return "cancelled_tasks"
+	}
+
+	// Priority 3: Completed (NextDueDate nil with completions)
+	hasCompletions := len(t.Completions) > 0 || t.CompletionCount > 0
+	if t.NextDueDate == nil && hasCompletions {
+		return "completed_tasks"
+	}
+
+	// Priority 4: In Progress
+	if t.InProgress {
+		return "in_progress_tasks"
+	}
+
+	// Get effective date: NextDueDate ?? DueDate
+	var effectiveDate *time.Time
+	if t.NextDueDate != nil {
+		effectiveDate = t.NextDueDate
+	} else {
+		effectiveDate = t.DueDate
+	}
+
+	if effectiveDate != nil {
+		// Normalize effective date to same timezone for calendar date comparison
+		// Task dates are stored as UTC but represent calendar dates (YYYY-MM-DD)
+		normalizedEffective := time.Date(
+			effectiveDate.Year(), effectiveDate.Month(), effectiveDate.Day(),
+			0, 0, 0, 0, now.Location(),
+		)
+
+		// Priority 5: Overdue (effective date before today)
+		if normalizedEffective.Before(startOfDay) {
+			return "overdue_tasks"
+		}
+
+		// Priority 6: Due Soon (effective date before threshold)
+		if normalizedEffective.Before(threshold) {
+			return "due_soon_tasks"
+		}
+	}
+
+	// Priority 7: Upcoming (default)
+	return "upcoming_tasks"
+}
+
 // TaskCompletion represents the task_taskcompletion table
 type TaskCompletion struct {
 	BaseModel