Refactor SQLPage functions into convention-driven modules (#1328)

* refactor: split SQLPage functions into one module each

Each built-in `sqlpage.*` function is now a plain `async fn` in its own
file under `sqlpage_functions/functions/`, with an ordinary Rust signature
and no marker comments or macros inside it.

Registration is automatic: `build.rs` lists the files in `functions/` into a
`sqlpage_functions!` call (the only generated code, one line per function),
and that macro declares the modules and builds the `SqlPageFunctionName`
enum the SQL engine dispatches on. There is no marker-comment parsing and no
per-argument codegen. Argument extraction, dispatch and return-value
conversion are ordinary generic code in function_traits.rs (`Extract`,
`Handler`, `IntoCowResult`), using the same `Fn`-arity trick axum uses for
handlers, so a function's argument and return types are read straight from
its signature.

Also folds in main's FileAccess centralization (#1327) for the file-reading
functions.

Verified: `cargo test` passes (148 lib + 70 integration tests, including
run_all_sql_test_files, the hmac webhook tests, the upload tests and
test_file_upload_through_runsql which exercises the &mut DbConn path).
`cargo clippy` and `cargo fmt --check` are clean.

* less magic

Author: lovasoa

src/webserver/database/sqlpage_functions/README.md

@@ -0,0 +1,35 @@
+# Built-in SQL functions
+
+Each built-in `sqlpage.*` function is a plain `async fn` in its own file in
+[`functions/`](functions). The file stem is the SQL function name and must match the Rust function it
+exports:
+
+```rust
+use std::borrow::Cow;
+
+use crate::webserver::http_request_info::RequestInfo;
+
+pub(super) async fn example(request: &RequestInfo, value: Option<Cow<'_, str>>) -> Option<String> {
+    // ...
+}
+```
+
+To add `sqlpage.example`, create `functions/example.rs` and add it to the
+[`sqlpage_functions!`](function_traits.rs) call in [`functions.rs`](functions.rs):
+
+```rust
+sqlpage_functions! {
+    // ...
+    example,
+}
+```
+
+The [`sqlpage_functions!`](function_traits.rs) macro declares the modules and generates the
+`SqlPageFunctionName` enum the SQL engine dispatches on. Per-function argument extraction, dispatch,
+and return-value conversion are handled generically in [`function_traits.rs`](function_traits.rs) by
+the `Extract`, `Handler`, and `IntoCowResult` traits. A function's argument and return types are read
+straight from its signature, so supported argument types are the types that implement `Extract` there.
+Functions can take up to five arguments.
+
+Keep helpers and unit tests that are specific to a function in that function's file. Shared helpers can
+be made `pub(super)` and imported by name from sibling function modules.