calendar: date an ambient event by its day word, and refuse stale ones

EventFromNotification took the date from the notification's own day, on the
grounds that a meeting notification is about today or it would not be firing.
Calendar apps break that. A 21:00 reminder reading "Tomorrow at 09:00" became
an event at 09:00 today, twelve hours in the past, and FactKey filed that
wrong meeting under today's date. Storing a wrong meeting is the one outcome
this parse works to avoid.

An explicit day word now moves the date: завтра, tomorrow, послезавтра,
сегодня, today, tonight. Matched whole, so послезавтра is not read as завтра,
and stripped from the summary so the meeting is not named after the day.
Anything still landing more than two hours before the notification is refused,
which covers the cases with no day word at all. The grace keeps a repost for a
meeting already under way.

Also matches the bearer scheme with EqualFold. A phone sending "bearer <tok>"
fell through to the X-Maven-Token branch and got a 401 that looked like a
wrong token. A bare token with no scheme in Authorization is now rejected
rather than silently accepted. The route table in mavweb gains its /api/ambient
row, and the missing calendar_busy write is recorded as a known gap.

Found in review of #57.

internal/calendar/ambient.go

@@ -36,13 +36,38 @@ type Notification struct {
 	Posted  time.Time `json:"posted_at"`
 }
 
+// ambientPastGrace — how far before the notification a derived start may sit
+// before the event is refused.
+//
+// The date is not in the clock reading, so it is inferred, and the inference is
+// only safe while the event is still roughly now. A 21:00 reminder reading
+// "Tomorrow at 09:00" would otherwise land at 09:00 TODAY, twelve hours in the
+// past, and FactKey would file that wrong meeting under today's date. Storing a
+// wrong meeting is the one outcome this file exists to avoid, so anything this
+// stale is dropped instead. The grace covers the ordinary case of a phone
+// reposting a notification for a meeting already under way.
+const ambientPastGrace = 2 * time.Hour
+
+// dayWords maps the words that move a notification off Posted's day. Only
+// explicit ones: an offset is a claim about which day, and guessing which day
+// is exactly the guess this parse refuses to make.
+var dayWords = map[string]int{
+	"завтра":      1,
+	"tomorrow":    1,
+	"сегодня":     0,
+	"today":       0,
+	"tonight":     0,
+	"послезавтра": 2,
+}
+
 // EventFromNotification turns a notification into the event it describes, or
 // reports false when it does not clearly describe one.
 //
 // It needs two things: a clock reading, and a summary that is not just that
-// clock reading. Everything else is defaulted — the date is Posted's day (a
-// meeting notification is about today or it would not be firing now), and a
-// bare start time gets DefaultReminderDuration.
+// clock reading. The date comes from Posted's day, shifted by an explicit day
+// word ("завтра", "tomorrow") when the notification carries one, and the result
+// is refused if it lands more than ambientPastGrace in the past. A bare start
+// time gets DefaultReminderDuration.
 func EventFromNotification(n Notification) (Event, bool) {
 	if n.Posted.IsZero() {
 		return Event{}, false
@@ -57,9 +82,14 @@ func EventFromNotification(n Notification) (Event, bool) {
 		return Event{}, false
 	}
 
-	y, m, d := n.Posted.Date()
+	y, m, d := n.Posted.AddDate(0, 0, dayOffset(line)).Date()
 	loc := n.Posted.Location()
 	s := time.Date(y, m, d, start.hour, start.min, 0, 0, loc)
+	// Too far in the past to be the meeting this notification is about. The day
+	// was inferred, so the honest reading is that the inference was wrong.
+	if s.Before(n.Posted.Add(-ambientPastGrace)) {
+		return Event{}, false
+	}
 	var e time.Time
 	if end != nil {
 		e = time.Date(y, m, d, end.hour, end.min, 0, 0, loc)
@@ -73,12 +103,38 @@ func EventFromNotification(n Notification) (Event, bool) {
 	return Event{Summary: summary, Start: s, End: e}, true
 }
 
+// dayOffset reports how many days off Posted's day the notification puts the
+// event. Words are matched whole, so "послезавтра" is not read as "завтра".
+func dayOffset(line string) int {
+	for _, f := range strings.Fields(strings.ToLower(line)) {
+		f = strings.Trim(f, ".,;:!?—–-()\"'«»")
+		if off, ok := dayWords[f]; ok {
+			return off
+		}
+	}
+	return 0
+}
+
+// stripDayWords removes the day word from a summary candidate. It named the
+// date, which now lives in Start, and leaving it in makes "Завтра Планёрка"
+// the name of the meeting.
+func stripDayWords(s string) string {
+	out := make([]string, 0, 8)
+	for _, f := range strings.Fields(s) {
+		if _, ok := dayWords[strings.Trim(strings.ToLower(f), ".,;:!?—–-()\"'«»")]; ok {
+			continue
+		}
+		out = append(out, f)
+	}
+	return strings.Join(out, " ")
+}
+
 // notificationSummary picks the text that names the meeting: the title when it
 // carries words, otherwise the body. The clock reading is stripped out — it
 // already lives in the times, and FactValue renders it again.
 func notificationSummary(n Notification) string {
 	for _, cand := range []string{n.Title, n.Text} {
-		s := strings.TrimSpace(stripClock(cand))
+		s := strings.TrimSpace(stripDayWords(stripClock(cand)))
 		s = strings.Trim(s, " \t-–—,;:@|·")
 		s = strings.Join(strings.Fields(s), " ")
 		if hasLetters(s) {