arm: offer 32-bit ARM at load, and fix `p` on carved code

Reported as "after c a few times and p at the entry point, Tab just flashes and
nothing decompiles". Three separate things, found by following it down:

**1. `p` failed on hand-carved code.** ida_funcs.add_func(ea) asks IDA to find
the function's end and on carved code it often can't — a run ending in a tail
call, or whose last instruction isn't recognised as a return, fails with no
reason given. add_func(ea, end) with an explicit end succeeds. define_func_run
tries IDA's way first, then falls back to the end of the contiguous instruction
run, and says which it used.

**2. The database was 64-bit, so Hex-Rays refused it regardless.** Bare `-parm`
gives an AArch64 database. Ask Hex-Rays for the failure object rather than
reading None as "dunno" and it says exactly what's wrong: "only 64-bit functions
can be decompiled in the current database". So the disassembly looked right and
F5 could never work.

That is decided at LOAD and cannot be corrected — inf_set_app_bitness(32)
afterwards makes the decompiler INTERR 50735. The fix is at the load dialog:
arm:ARMv7-A (most firmware), arm:ARMv7-M / arm:ARMv6-M (Cortex-M, Thumb only)
and arm:ARMv5TE now sit alongside 64-bit `arm`, labelled with their bitness.
With arm:ARMv7-A, experiments/fibonacci.bin decompiles:

  void __fastcall __noreturn sub_0(int a1) { int v2; v2 = sub_E3C(a1, 0); ... }

— and IDA's own auto-analysis finds 54 Thumb functions on load, versus none as
plain `arm`.

**3. `t` was silently building an undecompilable state.** It forced the SEGMENT
to 32-bit in a 64-bit database, which produces correct-looking disassembly that
F5 will never touch. It now says so and names the fix (Ctrl+L, arm:ARMv7-A)
rather than leaving you to discover it.

tools/verify_procs.py now reports each processor's resulting bitness, since that
is the reason the variants exist — and it compares against the base module name,
because a variant reports "ARM".

tests: test_thumb_ui.py +5 (13 total) — a 64-bit database warns and names the
fix, a 32-bit one finds functions by itself, Tab decompiles a Thumb function and
the result reads like C. test_formats.py +2 (34) pinning that a 32-bit variant is
offered and the ARM labels state their bitness. 209/0 scenarios, 26/0 blob, 30/0
project UI.

1 files changed, 18 insertions, 6 deletions

diff --git a/idatui/domain.py b/idatui/domain.py
index 8787431..9047d82 100644
--- a/idatui/domain.py
+++ b/idatui/domain.py
@@ -1397,12 +1397,24 @@ class Program:
                                f"@ {ea:#x}: {(r or {}).get('error', 'failed')}")
         return r
 
-    def define_func(self, ea: int) -> None:
-        """Create a function starting at ``ea`` (IDA's 'p')."""
-        res = self._first_result(
-            self.client.call("define_func", items=[{"addr": hex(ea)}]))
-        if res.get("error"):
-            raise IDAToolError("define_func", f"@ {ea:#x}: {res['error']}")
+    def define_func(self, ea: int) -> dict:
+        """Create a function starting at ``ea`` (IDA's 'p').
+
+        Prefers the injected tool, which works out the end when IDA can't;
+        falls back to the plain one for an older worker.
+        """
+        try:
+            r = self.client.call("define_func_run", addr=hex(ea))
+        except IDAToolError:
+            res = self._first_result(
+                self.client.call("define_func", items=[{"addr": hex(ea)}]))
+            if res.get("error"):
+                raise IDAToolError("define_func", f"@ {ea:#x}: {res['error']}")
+            return {"ok": True, "how": "legacy"}
+        if not isinstance(r, dict) or not r.get("ok"):
+            raise IDAToolError("define_func",
+                               f"@ {ea:#x}: {(r or {}).get('error', 'failed')}")
+        return r
 
     def undefine(self, ea: int, size: int | None = None) -> None:
         """Undefine the item at ``ea`` back to raw bytes (IDA's 'u')."""