feat(bal): Group A (timestamps + statuses + anticipate docs) and Group B (auto-sign) v0.3.4

Bump plugin version to 0.3.4 (manifest, __init__, plugin_base, VERSION).

GROUP A
- A1: remove block-height locktimes; the plugin now uses UNIX timestamps
  only. The NLOCKTIME_BLOCKHEIGHT_MAX guard is kept on purpose (it forces
  every locktime to be a timestamp). chk_locktime is now 2-arg; int_locktime
  and anticipate_locktime no longer accept blocks; RAW input only accepts d/y.
  Two now-dormant configs (LOCKTIME_BLOCKS, LOCKTIMEDELTA_BLOCKS) are kept with
  comments to avoid touching persisted keys.
- A2: rename PENDING -> MEMPOOL everywhere (label 'Mempool', yellow #ffce30);
  add new UPDATED status; ANTICIPATED & UPDATED keep VALID; documented
  set_status rules; backward-compat migration (old PENDING -> MEMPOOL).
- A3: clarify that anticipating to a future date only rebuilds (never
  invalidates), while only a past locktime invalidates (WillExpired). Code was
  already correct; only the comment and docs were fixed.

Colour follow-up: UPDATED lightened from #800080 to #b266b2 (more readable),
updated in theme.py, docs and the theme test.

GROUP B
- B1: verified the 'Create your will' button already opens the guided wizard
  (no code change needed).
- B2: new persisted AUTO_SIGN setting (default ON) with an 'Auto-sign on Check'
  checkbox in the settings dialog. When enabled, Check signs and broadcasts
  automatically; the wallet password is requested only for encrypted wallets.

B2 follow-up (fixes reported after testing):
- Remove the duplicate sign/broadcast cycle in lists.check(); build_will_task()
  already signs and broadcasts.
- Suppress the manual 'press Sign/Broadcast' hint and its popup when AUTO_SIGN
  is ON (kept when OFF).
- Make broadcast one-shot: removed the retry flag and the Exception('retry');
  failed will-executors stay PUSH_FAIL and are skipped (no endless retry).
  PUSHED transactions are already excluded from re-collection.

Docs: inheritance-options.md/.html and inheritance-flow.svg updated to v0.3.4.
Tests: 206 passing (new test_anticipate_manual_locktime, test_anticipate_past_locktime,
test_group_b_auto_sign; updated core/util, core/will_extra, gui/theme, gui/widgets).
CHANGELOG.md added with one numbered entry per task.

bal/gui/qt/dialogs.py

@@ -720,10 +720,18 @@ class BalBuildWillDialog(BalDialog):
             self.msg_set_invalidating(self.msg_error(e))
 
     def loop_push(self):
+        # Broadcast is "one-shot" (Group B / B2 follow-up): each selected
+        # will-executor is contacted ONCE. Transactions that are broadcast
+        # successfully become PUSHED; transactions whose server fails or times
+        # out are left as PUSH_FAIL and simply skipped - they are NOT retried
+        # automatically. A dead will-executor could otherwise never answer and
+        # make the plugin retry forever. The user can broadcast a failed
+        # transaction manually later with the "Broadcast" button. Note that
+        # get_willexecutor_transactions already excludes PUSHED transactions, so
+        # the successful ones are never re-sent on a subsequent run.
         if self._stopping:
             return
         self.msg_set_pushing(_("Broadcasting"))
-        retry = False
         try:
 
             willexecutors = Willexecutors.get_willexecutor_transactions(
@@ -744,7 +752,6 @@ class BalBuildWillDialog(BalDialog):
             # them sequentially after the parallel push, keeping the original
             # check logic untouched.
             already_present = []
-            retry_flag = {"value": False}
             total = len(selected)
             done = {"count": 0}
 
@@ -770,9 +777,10 @@ class BalBuildWillDialog(BalDialog):
                     for wid in willexecutor["txsids"]:
                         self.bal_window.willitems[wid].set_status("PUSHED", True)
                 else:
+                    # One-shot: mark the failed transactions and move on. They
+                    # are left as PUSH_FAIL (no automatic retry).
                     for wid in willexecutor["txsids"]:
                         self.bal_window.willitems[wid].set_status("PUSH_FAIL", True)
-                    retry_flag["value"] = True
                 done["count"] += 1
                 # Show the per-server result (Ok/Ko) in bold + color so the
                 # outcome stands out, keeping the server URL in normal weight.
@@ -781,11 +789,11 @@ class BalBuildWillDialog(BalDialog):
                 self.msg_set_pushing(_status_line())
 
             def on_timeout(url, willexecutor):
-                # The global deadline elapsed before this server answered.  Mark
-                # its txs as failed (so the user can retry later) and show it.
+                # The global deadline elapsed before this server answered. Mark
+                # its txs as failed and move on (one-shot: no automatic retry).
+                # The user can broadcast them manually later if desired.
                 for wid in willexecutor.get("txsids", []):
                     self.bal_window.willitems[wid].set_status("PUSH_FAIL", True)
-                retry_flag["value"] = True
                 self.msg_edit_row(
                     "{} : {}".format(url, self.msg_error(_("Timeout - no answer")))
                 )
@@ -820,7 +828,6 @@ class BalBuildWillDialog(BalDialog):
                 "{}/{} ({}s)".format(done["count"], total,
                                      int(time.time() - push_start))
             )
-            retry = retry_flag["value"]
 
             # Verify the "already present" servers (sequential, original logic).
             self.bal_plugin = self.bal_window.bal_plugin
@@ -851,15 +858,18 @@ class BalBuildWillDialog(BalDialog):
                         row,
                     )
 
-            if retry:
-                raise Exception("retry")
+            # One-shot broadcast: we deliberately do NOT raise/retry when some
+            # will-executors failed. Their transactions stay PUSH_FAIL and are
+            # left for the user to broadcast manually. This prevents an endless
+            # retry loop against a will-executor that may never answer.
 
         except Exception as e:
+            # Only genuine, unexpected errors reach here now (not the old
+            # "retry" signal). Report the error; do not loop.
             self.msg_set_pushing(self.msg_error(e))
             self.wait(10)
             if not self._stopping:
                 pass
-                # self.loop_push()
 
     def invalidate_task(self, password, bal_window, tx):
         if self._stopping:
@@ -1038,6 +1048,18 @@ class BalBuildWillDialog(BalDialog):
         short to be sure the user noticed the in-dialog line).
         """
         self._next_steps_hint = None
+        # Group B / B2: when AUTO_SIGN is ON the dialog has already signed and
+        # broadcast the will automatically, so the manual "press Sign/Broadcast"
+        # hints (and the follow-up popup) would be wrong/confusing. Suppress
+        # them in that case. When AUTO_SIGN is OFF, keep the previous behaviour
+        # and guide the user through the remaining manual steps.
+        try:
+            if self.bal_window.bal_plugin.AUTO_SIGN.get():
+                return
+        except Exception:
+            # If the setting cannot be read for any reason, fall back to the
+            # original behaviour (show the manual hints).
+            pass
         try:
             need_sign = False
             need_push = False