[LangRef] Clarify norecurse attribute definition when a function could occur in a cycle in dynamic call-graph (llvm#157087)

Update the definition of the `norecurse` attribute to forbid marking a
function as `norecurse` if any call path from its body may reach it
(possibly through an external function without a visible definition).
This makes it clear that `norecurse` excludes both direct and mutual
recursion, even when recursion could arise through callees in separate
modules.

This kind of scenario only arises when norecurse is forced through a llvm user option `-mllvm -force-attribute=<fname>:norecurse`

There are a few examples in
llvm#157081 which shows that the
function attribute inference incorrectly infers norecurse when the
behavior (as per new definition) is not enforced.

Author: usha1830

llvm/docs/LangRef.rst

@@ -2256,9 +2256,16 @@ For example:
     behavior at runtime if the function ever does dynamically return. Annotated
     functions may still raise an exception, i.a., ``nounwind`` is not implied.
 ``norecurse``
-    This function attribute indicates that the function does not call itself
-    either directly or indirectly down any possible call path. This produces
-    undefined behavior at runtime if the function ever does recurse.
+    This function attribute indicates that the function is not recursive and
+    does not participate in recursion. This means that the function never
+    occurs inside a cycle in the dynamic call graph.
+    For example:
+
+.. code-block:: llvm
+
+    fn -> other_fn -> fn       ; fn is not norecurse
+    other_fn -> fn -> other_fn ; fn is not norecurse
+    fn -> other_fn -> other_fn ; fn is norecurse
 
 .. _langref_willreturn: