force_refresh: propagate through unwrapped @with_solr_cache decorators

v1.12.9 added force_refresh URL parsing in handle_run_query and a
signature check in _run_query, but the check was looking for a
'force_refresh' parameter by name. The @with_solr_cache decorator in
solr_result_cache.py defines its wrapper as 'def wrapper(*args,
**kwargs)' without @functools.wraps, so inspect.signature(get_instances)
returns the wrapper's signature — no 'force_refresh' parameter visible
— and the kwarg was never forwarded. The SOLR-side cache kept serving
the stale 0 entry for FBbt_00007484 regardless of URL flag, even after
container restart.

Two fixes:

1. ha_api._run_query: also pass force_refresh when the function accepts
   **kwargs (VAR_KEYWORD parameter kind). The @with_solr_cache wrapper
   pops force_refresh off kwargs before delegating to the inner
   function, so this is safe even when the underlying function doesn't
   itself declare the parameter.

2. solr_result_cache.with_solr_cache: add @functools.wraps(func) so the
   decorated function's signature, name, qualname and docstring are
   preserved. Future introspection (and tooling like Sphinx) will then
   see the inner function's parameters as expected.

Verified path:
  URL ?force_refresh=true
  -> handle_run_query parses it, invalidates rcache entry
  -> _run_query sees VAR_KEYWORD in fn signature, adds to kwargs
  -> wrapper(*args, **kwargs) pops force_refresh, clears its SOLR entry
  -> inner get_instances recomputes from Owlery+Neo4j (~31,499 rows for
     FBbt_00007484) and the wrapper writes the fresh result back.

Author: Robbie1977

src/vfbquery/ha_api.py

@@ -358,7 +358,18 @@ def _run_query(short_form, func_name, force_refresh=False):
     if force_refresh:
         try:
             import inspect
-            if "force_refresh" in inspect.signature(fn).parameters:
+            params = inspect.signature(fn).parameters
+            # Pass force_refresh either when the function names it directly
+            # OR when it accepts **kwargs (which is what the
+            # @with_solr_cache wrapper does — it pops `force_refresh` off
+            # kwargs before calling the inner function). Without the **kwargs
+            # check we miss every decorated function, because the wrapper has
+            # signature (*args, **kwargs) — no `force_refresh` parameter
+            # name — and the SOLR cache keeps serving stale entries.
+            accepts_kwargs = any(
+                p.kind == inspect.Parameter.VAR_KEYWORD for p in params.values()
+            )
+            if "force_refresh" in params or accepts_kwargs:
                 kwargs["force_refresh"] = True
         except (TypeError, ValueError):
             # builtins / C functions have no introspectable signature; skip.

src/vfbquery/solr_result_cache.py

@@ -10,6 +10,7 @@
 Neo4j queries and data processing.
 """
 
+import functools
 import json
 import os
 import re
@@ -765,6 +766,7 @@ def get_term_info(short_form, force_refresh=False, **kwargs):
     The decorated function can accept a 'force_refresh' parameter to bypass cache.
     """
     def decorator(func):
+        @functools.wraps(func)
         def wrapper(*args, **kwargs):
             # Check if force_refresh is requested (pop it before passing to function)
             force_refresh = kwargs.pop('force_refresh', False)