feat(notes): share a note with a person, not only through a project

Until now a note was shared exactly one way: file it in a shared project, and
everyone who could read the project could read the note. That is right when the
note belongs with a body of work and wrong when it is just "let Sofie see this" —
it made you stand up a project to hand over a single page.

A note can now be shared with named people directly, at viewer or editor — the
same two roles a project membership uses, so there is one idea of a role in the
program and not two. The paths stack: a note can be loose, filed, shared with
people, or any mix, and access is the most any of them allow.

The store:
  - note_shares (migration 0030): note ↔ user ↔ role, one row per person, owner
    recorded. Visibility (AllNotes, and search via mayTouchNote) widens to include
    notes shared directly with the reader.
  - the effective role folds a direct share on top of the owner and project paths.

The rules, drawn where they protect the owner:
  - read = viewer, edit text = editor, on any path.
  - MOVE a note (change its project) is owner-only: an editor filing it into a
    project the owner is not in would take the owner's own note away from them.
  - DELETE is owner or project-editor — a direct share, however high its role,
    does not reach to throwing the note away.
  - SHARE and UNSHARE are the owner's alone, like a project's invitations.
  - the picker is everyone on the instance (a closed, invited set) minus who is
    already on the note; a made-up id and the owner themselves are refused.

The list:
  - a "Delt med mig" group at the top, collapsible, that appears only when it has
    something in it — the same rule Favoritter follows — so it costs nothing when
    you share nothing. A shared note lives there, not also in a time bucket.
  - every shared note carries a small chip in its owner's avatar colour, the
    project mark's shape said for a person.
  - no star or archive button on a note somebody else owns: those change the note
    itself, and it is not yours to put away.
  - the editor grows a "Del med personer" panel for the owner: who can see it, at
    what role, and an add row drawn from the instance's other people.

The old comment in the notes footer argued against a note having an access list
of its own. That was the right call until the case it did not cover — sharing
without a project — turned out to be the one actually asked for. Updated to match.

Person now carries json tags, so a note's owner serialises as id/name/avatar_color
like every other person in the API rather than as Go field names.

Tests: a shared note reaches the other person marked and owned; a viewer reads but
cannot write; an editor writes but cannot re-share or delete; unshare removes
access and is owner-only; the candidate list excludes who is already on and the
owner; and a made-up id and self are refused. OpenAPI covers the three new routes.

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

web/src/lib/api.js

@@ -405,6 +405,12 @@ export const api = {
 	deleteNote: (id) => del(`/notes/${id}`),
 	notesLinking: (kind, targetId) => get(`/notes/linking/${kind}/${encodeURIComponent(targetId)}`),
 
+	// Sharing a note with people directly — its own access list, beside the project
+	// path. Owner only; the list call also returns who it can still be shared with.
+	noteShares: (id) => get(`/notes/${id}/shares`),
+	shareNote: (id, userId, role) => post(`/notes/${id}/shares`, { user_id: userId, role }),
+	unshareNote: (id, userId) => del(`/notes/${id}/shares/${userId}`),
+
 	// Mailboxes read over IMAP. Each belongs to the person who connected it, so
 	// there is no instance-wide registration behind these the way Gmail has one.
 	mailboxes: () => get('/mailboxes'),

web/src/lib/locales/da.js

@@ -16,10 +16,23 @@
  */
 export const da = {
 	// --- the shell ---------------------------------------------------------------
-	'notes.shareWith': 'Del i',
-	'notes.private': 'Kun mig',
+	'notes.shareWith': 'Læg i projekt',
+	'notes.private': 'Intet projekt',
 	'notes.shared': 'Noten er delt med projektets folk.',
 	'notes.unshared': 'Noten er din igen.',
+	// Deling med enkeltpersoner, ved siden af projektet.
+	'notes.groupSharedWithMe': 'Delt med mig',
+	'notes.sharedBy': 'Delt af {name}',
+	'notes.sharePeople': 'Del med personer',
+	'notes.sharePick': 'Vælg en person …',
+	'notes.shareAdd': 'Del',
+	'notes.shareRoleViewer': 'Kan læse',
+	'notes.shareRoleEditor': 'Kan rette',
+	'notes.shareRemove': 'Fjern adgang',
+	'notes.shareNobody': 'Ikke delt med nogen endnu.',
+	'notes.sharedToast': 'Delt med {name}.',
+	'notes.unsharedPerson': '{name} kan ikke længere se noten.',
+	'notes.shareOwnerOnly': 'Kun ejeren kan dele noten.',
 	'notes.save': 'Gem',
 	'notes.format': 'Formatér',
 	'notes.bold': 'Fed',

web/src/lib/locales/en.js

@@ -12,10 +12,23 @@
  */
 export const en = {
 	// --- the shell ---------------------------------------------------------------
-	'notes.shareWith': 'Share in',
-	'notes.private': 'Only me',
+	'notes.shareWith': 'File in project',
+	'notes.private': 'No project',
 	'notes.shared': "The note is shared with the project's people.",
 	'notes.unshared': 'The note is yours again.',
+	// Sharing with individual people, alongside the project.
+	'notes.groupSharedWithMe': 'Shared with me',
+	'notes.sharedBy': 'Shared by {name}',
+	'notes.sharePeople': 'Share with people',
+	'notes.sharePick': 'Choose someone …',
+	'notes.shareAdd': 'Share',
+	'notes.shareRoleViewer': 'Can view',
+	'notes.shareRoleEditor': 'Can edit',
+	'notes.shareRemove': 'Remove access',
+	'notes.shareNobody': 'Not shared with anyone yet.',
+	'notes.sharedToast': 'Shared with {name}.',
+	'notes.unsharedPerson': '{name} can no longer see the note.',
+	'notes.shareOwnerOnly': 'Only the owner can share the note.',
 	'notes.save': 'Save',
 	'notes.format': 'Format',
 	'notes.bold': 'Bold',