[fix](editlog) Fix BDBEnvironment.close() ConcurrentModificationException with two-phase close

BDBEnvironment.close() iterates openedDatabases without acquiring
lock.writeLock(), while openDatabase() concurrently modifies the same
ArrayList under the write lock. This causes ConcurrentModificationException
when a RollbackException triggers close() on the replayer thread while
HTTP/heartbeat/RPC handler threads call openDatabase() via getMaxJournalId().

Fix with two-phase close pattern:
- Phase 1 (under writeLock): detach all resources — copy openedDatabases
  to a local list, clear the original, and null out epochDB and
  replicatedEnvironment fields. This atomically makes them invisible to
  concurrent openDatabase() callers.
- Phase 2 (outside lock): perform the actual db.close() and env.close()
  calls without holding the lock, avoiding blocking unrelated threads
  during potentially slow close operations.

Also fix misleading "will exit" in log messages — close() does not exit.

Author: dataroaring

fe/fe-core/src/main/java/org/apache/doris/journal/bdbje/BDBEnvironment.java

@@ -479,31 +479,52 @@ public List<Long> getDatabaseNames() {
         return ret;
     }
 
-    // Close the store and environment
+    // Close the store and environment.
+    // Two-phase close: detach resources under the write lock, then close them outside the lock
+    // to avoid blocking openDatabase() callers during potentially slow close() calls.
     public void close() {
-        for (Database db : openedDatabases) {
+        List<Database> databasesToClose;
+        Database epochDBToClose = null;
+        ReplicatedEnvironment envToClose = null;
+
+        lock.writeLock().lock();
+        try {
+            databasesToClose = new ArrayList<>(openedDatabases);
+            openedDatabases.clear();
+
+            if (epochDB != null) {
+                epochDBToClose = epochDB;
+                epochDB = null;
+            }
+
+            if (replicatedEnvironment != null) {
+                envToClose = replicatedEnvironment;
+                replicatedEnvironment = null;
+            }
+        } finally {
+            lock.writeLock().unlock();
+        }
+
+        // Close resources outside the lock
+        for (Database db : databasesToClose) {
             try {
                 db.close();
             } catch (DatabaseException exception) {
-                LOG.error("Error closing db {} will exit", db.getDatabaseName(), exception);
+                LOG.error("Error closing db {}", db.getDatabaseName(), exception);
             }
         }
-        openedDatabases.clear();
 
-        if (epochDB != null) {
+        if (epochDBToClose != null) {
             try {
-                epochDB.close();
-                epochDB = null;
+                epochDBToClose.close();
             } catch (DatabaseException exception) {
-                LOG.error("Error closing db {} will exit", epochDB.getDatabaseName(), exception);
+                LOG.error("Error closing epoch db {}", epochDBToClose.getDatabaseName(), exception);
             }
         }
 
-        if (replicatedEnvironment != null) {
+        if (envToClose != null) {
             try {
-                // Finally, close the store and environment.
-                replicatedEnvironment.close();
-                replicatedEnvironment = null;
+                envToClose.close();
             } catch (DatabaseException exception) {
                 LOG.error("Error closing replicatedEnvironment", exception);
             }