CODAGT-721: Add chat_message_search_text extraction function

Issue: https://linear.app/codercom/issue/CODAGT-721
Parent: CODAGT-591 (Implement Chat History Search)
Branch: cian/codagt-721-add-chat_message_search_text-extraction-function
Deliverable: one draft PR containing a single SQL migration pair plus tests.

Context

The chat search RFC (Notion: "Chat Messages Search", post-PRD follow-up) settled on
a partial expression GIN index over
to_tsvector('simple', chat_message_search_text(content)) on chat_messages,
built at runtime with CREATE INDEX CONCURRENTLY by a dbpurge-style task
(CODAGT-722). This issue lands only the IMMUTABLE extraction function the index
expression needs. No index, no trigger, no stored column, no callers.

Requirements (from issue + RFC)

• New migration pair under coderd/database/migrations (next number after
  000535; use create_migration.sh).
• chat_message_search_text(content jsonb) RETURNS text, IMMUTABLE,
  single statement, no CONCURRENTLY.
• .down.sql drops the function.
• Semantics (matches the RFC sketch and the existing
  GetChatUserPromptsByChatID extraction in coderd/database/queries/chats.sql:422):
  • If content is NULL or jsonb_typeof(content) <> 'array' (legacy
    content_version=0 scalar strings): return NULL. This intentionally excludes
    legacy message content per the RFC.
  • Otherwise: string_agg(part->>'text', ' ' ORDER BY ordinality) over
    jsonb_array_elements(content) where part->>'type' = 'text'.
  • Only type='text' parts. Reasoning, tool-call/result, file, source,
    context-file, and skill parts are excluded (role/visibility/deleted
    filtering belongs in the index predicate, CODAGT-722, not here).
  • Array with no text parts: string_agg over zero rows returns NULL. Fine.
• Implementation notes:
  • LANGUAGE sql (not plpgsql): a single-expression SQL function is enough,
    inlinable, and trivially IMMUTABLE. IMMUTABLE + PARALLEL SAFE.
  • IMMUTABLE is a promise, not enforced; the function reads only its
    argument, so the promise holds.

Red: tests first

Migration-level DB tests. Where: a new test in
coderd/database/migrations/migrate_test.go style is overkill; instead add a
Postgres-backed test (e.g. coderd/database/chat_message_search_text_test.go
or extend an existing querier test file per .claude/docs/DATABASE.md and
TESTING.md conventions; confirm placement against how other SQL functions are
tested during implementation). Test executes
SELECT chat_message_search_text($1::jsonb) directly. Cases:

1. Array with one text part → that text.
2. Array with text parts interleaved with non-text parts (reasoning,
   tool-call) → text parts joined by a single space, in order.
3. Scalar JSONB ("hello") → NULL.
4. Empty array ([]) → NULL.
5. NULL input → NULL.
6. Array element missing type or missing text → ignored / NULL text
   skipped (string_agg skips NULLs).

Also: TestMigrateUpDownUp style idempotence is already covered by the
existing migration framework; no extra work unless make test says otherwise.

Green: implementation

1. ./coderd/database/migrations/create_migration.sh chat_message_search_text

2. Up migration:

   CREATE FUNCTION chat_message_search_text(content jsonb) RETURNS text
   LANGUAGE sql IMMUTABLE PARALLEL SAFE AS $$
       SELECT string_agg(part->>'text', ' ' ORDER BY ordinality)
       FROM jsonb_array_elements(content) WITH ORDINALITY AS t(part, ordinality)
       WHERE jsonb_typeof(content) = 'array'
         AND part->>'type' = 'text'
   $$;

   Note: jsonb_array_elements on a scalar raises an error, so the scalar
   guard cannot live only in the WHERE clause of a FROM over it. Use
   CASE WHEN jsonb_typeof(content) = 'array' THEN (subquery) END or plpgsql
   with an IF, as in the RFC sketch. Decide during implementation; the tests
   pin the behavior either way.

3. Down migration: DROP FUNCTION chat_message_search_text(jsonb);

4. make gen (dump.sql picks up the function; no sqlc changes expected).

5. Run the new tests + make test RUN=<new test>.

Refactor

• Compare the final function against GetChatUserPromptsByChatID; do NOT
  rewrite that query to use the new function in this PR (out of scope), but
  note the follow-up if the duplication is exact.
• Re-check comment quality in the migration (explain the scalar guard and why
  only type='text' parts are indexed).

Verification

• make gen produces no diff outside the migration + dump.sql.
• make lint, make test RUN=... pass.
• Migration up/down/up applies cleanly (covered by migration tests).

Assumptions (flag in PR)

• Separator is a single space (RFC sketch used ' '; the existing
  user-prompts query uses ''). Space is correct for tokenization.
• Empty array returns NULL, not empty string. Acceptance criteria says
  "null/empty"; NULL is what string_agg gives and is fine for
  to_tsvector (the index expression handles NULL).
• Legacy (non-array) content returns NULL by design; RFC explicitly excludes
  legacy message content from search.