fix(boot): drop the redundant auto-bootDelay network poll

In auto bootDelay mode, handleBootDelay() polled up to 5 seconds for an
NTP-capable interface before postNetwork's concurrent audio/network
threads even started -- serial dead time on every boot, and a flat 5s
loss on a box with no network at all (which then paid the link-wait
timeout again anyway).

The poll was load-bearing when it was added: waitForInterfacesUp() then
bailed out instantly if no interface had link yet, so a fast-booting
board could skip the IP/NTP wait before its NIC came up. Since the June
rework, waitForInterfacesUp() itself waits up to half its timeout for
link before deciding anything, and handleTimeSyncWait() re-checks for
an NTP-capable interface after that wait -- so the pre-poll's verdict
was computed and then discarded. Verified on a Pi 5 booting with the
network not yet up: the in-function link wait catches it (3s) and the
time-sync path proceeds normally.

Also give announceIPAddresses() a bounded wait for an address: the boot
IP wait can time out with the DHCP lease landing moments later, and the
announce service previously assumed the address was already there and
silently skipped announcing. It runs off fppd's critical path, so
waiting there is free.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: dkulp

src/boot/FPPINIT.cpp

@@ -371,7 +371,11 @@ int main(int argc, char* argv[]) {
                 removeDummyInterface();
                 checkWLANInterface();
                 removeDummyInterface();
-                waitForInterfacesUp(100, true); // wait for an IP (needed for the time-sync wait); boot path may recover a dead USB adapter
+                // Wait for an actual IP, not just link: fppd starts right after
+                // this service and needs the address in place (socket binds,
+                // MultiSync), and the time-sync wait below may need the network
+                // too. The boot path may also recover a dead USB adapter.
+                waitForInterfacesUp(100, true);
                 // A wedged USB adapter has queued a reboot. Everything below is
                 // setup for a boot that is about to end, and this service is on
                 // fppd's dependency chain -- overrunning its start timeout here

src/boot/FPPINIT_Network.cpp

@@ -755,26 +755,15 @@ void handleBootDelay() {
         unlink(delayFile.c_str());
         unlink(skipFile.c_str());
     } else if (i == -1) {
-        // Auto mode: check if we have any network interfaces that could get NTP
-        // If not, skip the time wait entirely and clean up flag file now
-
-        // On a Pi5, it takes about 4.1s from when fppinit is called to when eth0
-        // will report a link up. Since we want to wait for NTP if the network is
-        // available, we need to wait
-        const auto processor_count = std::thread::hardware_concurrency();
-        if (processor_count > 2) {
-            int count = 0;
-            while (!hasNetworkInterfaceForNTP() && count < 50) {
-                std::this_thread::sleep_for(std::chrono::milliseconds(100));
-                count++;
-            }
-            if (!hasNetworkInterfaceForNTP()) {
-                printf("FPP - No network interface found, skipping boot delay\n");
-                unlink(delayFile.c_str());
-                unlink(skipFile.c_str());
-                return;
-            }
-        }
+        // Auto mode: nothing to wait on here. The is-there-an-NTP-capable-network
+        // decision and the quick SNTP set both happen in handleTimeSyncWait(),
+        // which runs on the network thread after waitForInterfacesUp() has
+        // already waited for link/IP properly. This used to pre-poll up to 5s
+        // for an interface, but that only serialized boot ahead of the
+        // concurrent audio/network threads and its verdict was recomputed
+        // later anyway. Just clean up any stale flag files.
+        unlink(delayFile.c_str());
+        unlink(skipFile.c_str());
     }
 }
 
@@ -1193,6 +1182,13 @@ void announceIPAddresses() {
         return;
     }
     std::string announce = buildIPAnnounceString();
+    // postNetwork's IP wait can time out with the DHCP lease landing moments
+    // later; this service is off fppd's critical path, so give the address a
+    // bounded chance to appear rather than silently skipping the announcement.
+    for (int i = 0; announce.empty() && i < 75; ++i) {
+        std::this_thread::sleep_for(std::chrono::milliseconds(200));
+        announce = buildIPAnnounceString();
+    }
     if (announce.empty()) {
         printf("FPP - announceIP: no usable IP address to announce\n");
         return;