[flang] Allow forward reference to ENTRY from generic interface

[klausler]

Summary

The CreateEntry() function in name resolution needs to allow for the name
of an alternate entry point already having been declared in the outer scope
as the homonymous specific procedure of a generic interface; e.g.,

interface foo
  module procedure foo
end interface
subroutine bar
  entry foo
end subroutine

flang/lib/Semantics/resolve-names.cpp

if (resultName.source == subprogram.name()) { // C1574
           badResultName = true;
         }
       }
     }
   }
   if (outer.IsModule() && !attrs.test(Attr::PRIVATE)) {
     attrs.set(Attr::PUBLIC);
   }
-  Symbol &entrySymbol{MakeSymbol(outer, entryName.source, attrs)};
+  Symbol *entrySymbol{FindInScope(outer, entryName.source)};
+  if (entrySymbol) {
+    if (auto *generic{entrySymbol->detailsIf<GenericDetails>()}) {
+      if (auto *specific{generic->specific()}) {
+        // Forward reference to ENTRY from a generic interface
+        entrySymbol = specific;
+        entrySymbol->attrs() |= attrs;
+      }
+    }
+  } else {
+    entrySymbol = &MakeSymbol(outer, entryName.source, attrs);
+  }
   SubprogramDetails entryDetails;
   entryDetails.set_entryScope(currScope());
-  entrySymbol.set(subpFlag);
+  entrySymbol->set(subpFlag);
   if (subpFlag == Symbol::Flag::Function) {
     Symbol *result{nullptr};
     EntityDetails resultDetails;
     resultDetails.set_funcResult(true);
     if (distinctResultName) {
       if (!badResultName) {
         // RESULT(x) can be the same explicitly-named RESULT(x) as
         // the enclosing function or another ENTRY.
if (subpFlag == Symbol::Flag::Function) {
     }
     if (result) {
       entryDetails.set_result(*result);
     }
   }
   if (subpFlag == Symbol::Flag::Subroutine ||
       (distinctResultName && !badResultName)) {
     Symbol &assoc{MakeSymbol(entryName.source)};
-    assoc.set_details(HostAssocDetails{entrySymbol});
+    assoc.set_details(HostAssocDetails{*entrySymbol});
     assoc.set(Symbol::Flag::Subroutine);
   }
-  Resolve(entryName, entrySymbol);
-  entrySymbol.set_details(std::move(entryDetails));
+  Resolve(entryName, *entrySymbol);
+  Details details{std::move(entryDetails)};
+  entrySymbol->set_details(std::move(entryDetails));
 }
 
 void SubprogramVisitor::PostEntryStmt(const parser::EntryStmt &stmt) {
   // The entry symbol should have already been created and resolved
   // in CreateEntry(), called by BeginSubprogram(), with one exception (below).
   const auto &name{std::get<parser::Name>(stmt.t)};
   Scope &inclusiveScope{InclusiveScope()};
   if (!name.symbol) {