feat(updater): authenticate GitHub polling and track the real release repo

felis-api's coord was the placeholder "felis/felis", which resolves against
nothing on real GitHub. It is now MliroLirrorsIngenuity/Felis — the same slug
deploy/bootstrap.sh clones from — so update reporting for the control plane
itself is live rather than parked.

That repo is private today, so the github source gained an optional token, read
from FELIS_GITHUB_TOKEN: the variable bootstrap already needs, so an operator
sets one value once. It comes from the environment and is never compiled in. A
constant would be committed to the very repository it protects, ship inside
every felis binary where strings(1) recovers it, reach every node the image is
imported onto, and need a rebuild and a redeploy to rotate.

Empty stays the correct posture for the other tracked components — k3s and
cloudflared are public — and an empty token sends no Authorization header at
all rather than an empty one.

GitHub answers 404, not 401 or 403, for a private repo the caller cannot see,
so "no token" and "no stable release published yet" arrive as the same status.
On an unauthenticated 404 the error now names both causes and the variable that
fixes the actionable one. With a token already set that hint would be wrong, so
it is suppressed.

Tests pin both halves: the Bearer header is sent only when the token is set,
and the diagnostic names the variable only when it is not.

doc.go's CAVEATS bullet still described the coord as a placeholder and the
component as "dark at runtime". Both were true only until this change; it now
records the real condition, which is that the component resolves like the others
but needs a credential while the repo is private.

internal/updater/github_test.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"net/http"
 	"net/http/httptest"
+	"strings"
 	"testing"
 )
 
@@ -140,3 +141,63 @@ func TestGitHubFailsClosedOnUnparseableTag(t *testing.T) {
 		t.Fatalf("want error on an unparseable tag, got %q", v.String())
 	}
 }
+
+// TestGitHubSendsTokenOnlyWhenSet proves the credential reaches the wire as a Bearer
+// header when present, and that an empty token sends NO Authorization header at all —
+// the public repos (k3s, cloudflared) must keep working with no credential configured.
+func TestGitHubSendsTokenOnlyWhenSet(t *testing.T) {
+	for _, tc := range []struct {
+		name, token, wantAuth string
+	}{
+		{"a token is sent as a Bearer credential", "ghp_secret", "Bearer ghp_secret"},
+		{"no token sends no Authorization header", "", ""},
+	} {
+		t.Run(tc.name, func(t *testing.T) {
+			var gotAuth string
+			srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				gotAuth = r.Header.Get("Authorization")
+				_, _ = w.Write([]byte(`{"tag_name":"v1.2.3","prerelease":false,"draft":false}`))
+			}))
+			defer srv.Close()
+
+			g := newTestGitHub(srv)
+			g.token = tc.token
+			if _, err := g.latestStable(context.Background(), "acme/private"); err != nil {
+				t.Fatalf("latestStable: %v", err)
+			}
+			if gotAuth != tc.wantAuth {
+				t.Errorf("Authorization = %q, want %q", gotAuth, tc.wantAuth)
+			}
+		})
+	}
+}
+
+// TestGitHubNamesTheTokenOnAnUnauthenticated404 pins the diagnostic that makes a private
+// repo debuggable. GitHub hides a repo the caller cannot see behind 404 rather than 401,
+// so this status is genuinely ambiguous; the error must name BOTH causes and the env var
+// that fixes the actionable one. With a token already set that hint would be wrong, so it
+// must not appear.
+func TestGitHubNamesTheTokenOnAnUnauthenticated404(t *testing.T) {
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		http.Error(w, `{"message":"Not Found"}`, http.StatusNotFound)
+	}))
+	defer srv.Close()
+
+	g := newTestGitHub(srv)
+	_, err := g.latestStable(context.Background(), "acme/private")
+	if err == nil {
+		t.Fatal("want an error on 404")
+	}
+	if !strings.Contains(err.Error(), tokenEnv) {
+		t.Errorf("unauthenticated 404 must name %s so an operator knows the fix; got: %v", tokenEnv, err)
+	}
+
+	g.token = "ghp_secret"
+	_, err = g.latestStable(context.Background(), "acme/private")
+	if err == nil {
+		t.Fatal("want an error on 404")
+	}
+	if strings.Contains(err.Error(), tokenEnv) {
+		t.Errorf("a 404 WITH a token set must not blame the missing token; got: %v", err)
+	}
+}