feat(calendar): einzelnen Termin aus einer Reihe streichen

Beim Löschen eines Serientermins gibt es jetzt zwei Wege statt einem:
"Nur diesen Termin" und "Ganze Reihe". Das sind zwei verschiedene
Absichten, und sie sind nicht ineinander umkehrbar -- eine einzelne
Ja/Nein-Rückfrage musste sich bisher für eine davon entscheiden, und die
andere war gar nicht erreichbar.

"Nur diesen" wird als EXDATE in der Reihe vermerkt, so wie das
iCalendar-Format eine Ausnahme ausdrückt: Die Reihe behält ihre Regel
und ihre UID, jeder CalDAV-Client versteht es ohne Zutun. Bewusst nicht
über ein Aufspalten in zwei Reihen gelöst -- das änderte die UID, und
alle Geräte hielten den Rest für einen neuen Termin.

Ein zweites Streichen desselben Termins bleibt folgenlos (sonst liefe
die Datei mit der Zeit mit doppelten EXDATE-Zeilen voll), und bei einem
Einzeltermin ohne Wiederholung sind beide Wege dasselbe -- der Server
löscht dann einfach, statt den Aufrufer mit einer Unterscheidung zu
behelligen, die es dort nicht gibt.

Selbsttest um sechs Prüfungen erweitert (25 grün): Reihe steht,
Streichen liefert 204, der gestrichene Termin fehlt und der Rest bleibt,
EXDATE steht im .ics, zweimal Streichen ist harmlos, ganze Reihe löschen
räumt alles weg.

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

backend/internal/calendar/events_api.go

@@ -629,6 +629,61 @@ func (h *APIHandler) UpdateEvent(w http.ResponseWriter, r *http.Request) {
 	response.JSON(w, http.StatusOK, dto)
 }
 
+var errNotRecurring = &icalError{"calendar: event has no recurrence"}
+
+// excludeOccurrence streicht einen einzelnen Termin aus einer Reihe, indem
+// er als EXDATE vermerkt wird – die Art, wie das iCalendar-Format eine
+// Ausnahme ausdrückt. Die Reihe selbst bleibt mit ihrer Regel bestehen, und
+// jeder CalDAV-Client versteht das ohne Zutun.
+//
+// Bewusst **nicht** so gelöst, dass die Reihe in zwei Reihen zerlegt wird:
+// Das änderte die UID, und alle Geräte hielten den Rest für einen neuen
+// Termin.
+func (h *APIHandler) excludeOccurrence(r *http.Request, calID uuid.UUID, uid string, at time.Time) error {
+	obj, err := h.store.GetObjectByUID(r.Context(), calID, uid)
+	if err != nil {
+		return err
+	}
+	cal, err := ical.NewDecoder(strings.NewReader(obj.Data)).Decode()
+	if err != nil {
+		return err
+	}
+	ev := firstEventComponent(cal)
+	if ev == nil {
+		return errNoEventComponent
+	}
+	if rule, err := ev.Props.RecurrenceRule(); err != nil || rule == nil {
+		return errNotRecurring
+	}
+
+	startProp := ev.Props.Get(ical.PropDateTimeStart)
+	allDay := startProp != nil && isDateOnly(startProp)
+
+	// Schon ausgetragen? Dann nichts tun – ein zweites EXDATE auf denselben
+	// Zeitpunkt wäre harmlos, aber die Datei liefe mit der Zeit voll.
+	for _, ex := range ev.Props[ical.PropExceptionDates] {
+		if t, err := ex.DateTime(time.UTC); err == nil && t.Equal(at) {
+			return nil
+		}
+	}
+
+	ex := ical.NewProp(ical.PropExceptionDates)
+	if allDay {
+		ex.SetDate(at)
+	} else {
+		ex.SetDateTime(at)
+	}
+	ev.Props.Add(ex)
+
+	data, err := encodeICal(cal)
+	if err != nil {
+		return err
+	}
+	start, end := timeRange(cal)
+	_, err = h.store.PutObject(r.Context(), calID, uid, obj.Component, data, etagFor(data), start, end)
+	return err
+}
+
 func (h *APIHandler) writeEvent(r *http.Request, calID uuid.UUID, uid string, body eventBody) (*EventDTO, error) {
 	cal := buildEventICal(uid, body)
 	data, err := encodeICal(cal)
@@ -643,7 +698,11 @@ func (h *APIHandler) writeEvent(r *http.Request, calID uuid.UUID, uid string, bo
 	return eventFromObject(obj)
 }
 
-// DELETE /api/v1/calendars/{id}/events/{uid}
+// DELETE /api/v1/calendars/{id}/events/{uid}[?occurrence=<RFC3339>]
+//
+// Ohne occurrence verschwindet der Termin ganz – bei einer Reihe also die
+// **ganze** Reihe. Mit occurrence fällt nur dieser eine Termin aus; die Reihe
+// bleibt bestehen und behält ihre Regel.
 func (h *APIHandler) DeleteEvent(w http.ResponseWriter, r *http.Request) {
 	calID, ok := h.calendarOf(r)
 	if !ok {
@@ -651,6 +710,33 @@ func (h *APIHandler) DeleteEvent(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	uid := chi.URLParam(r, "uid")
+
+	if occ := r.URL.Query().Get("occurrence"); occ != "" {
+		at, err := time.Parse(time.RFC3339, occ)
+		if err != nil {
+			response.Error(w, http.StatusBadRequest, "invalid occurrence")
+			return
+		}
+		switch err := h.excludeOccurrence(r, calID, uid, at.UTC()); err {
+		case nil:
+			response.NoContent(w)
+		case ErrNotFound:
+			response.Error(w, http.StatusNotFound, "event not found")
+		case errNotRecurring:
+			// Kein Serientermin: Dann ist „nur dieser" dasselbe wie „ganz
+			// weg" – also einfach löschen, statt den Aufrufer mit einer
+			// Unterscheidung zu behelligen, die es hier nicht gibt.
+			if err := h.store.DeleteObject(r.Context(), calID, uid); err != nil && err != ErrNotFound {
+				response.Error(w, http.StatusInternalServerError, "delete event failed")
+				return
+			}
+			response.NoContent(w)
+		default:
+			response.Error(w, http.StatusInternalServerError, "delete occurrence failed")
+		}
+		return
+	}
+
 	if err := h.store.DeleteObject(r.Context(), calID, uid); err == ErrNotFound {
 		response.Error(w, http.StatusNotFound, "event not found")
 		return