rhashtable: Fix rhashtable_next_key() build warnings

rhashtable.o builds with warnings as rhashtable_next_key() kdoc
from lib/rhashtable.c does not have the arguments descriptions.

Move rhashtable_next_key() kdoc from header to c file, matching
other functions.

Move rhashtable_next_key() next to the other forward declarations
in the header file.

Reported-by: kernel test robot <lkp@intel.com>
Closes: https://lore.kernel.org/oe-kbuild-all/202606061925.WI4bYI8k-lkp@intel.com/
Fixes: 8f4fa9f ("rhashtable: Add rhashtable_next_key() API")
Signed-off-by: Mykyta Yatsenko <yatsenko@meta.com>
Link: https://lore.kernel.org/r/20260606-rhash_fixes_1-v1-1-932ab036e6bc@meta.com
Signed-off-by: Alexei Starovoitov <ast@kernel.org>

Author: mykyta5

include/linux/rhashtable.h

@@ -263,6 +263,8 @@ struct rhash_lock_head __rcu **__rht_bucket_nested(
 struct rhash_lock_head __rcu **rht_bucket_nested_insert(
 	struct rhashtable *ht, struct bucket_table *tbl, unsigned int hash);
 
+void *rhashtable_next_key(struct rhashtable *ht, const void *prev_key);
+
 #define rht_dereference(p, ht) \
 	rcu_dereference_protected(p, lockdep_rht_mutex_is_held(ht))
 
@@ -650,46 +652,6 @@ static __always_inline struct rhash_head *__rhashtable_lookup(
 	return NULL;
 }
 
-/**
- * rhashtable_next_key - return next element after a given key
- * @ht:		hash table
- * @prev_key:	pointer to previous key, or NULL for the first element
- *
- * WARNING: this walk is highly unstable. Unlike rhashtable_walk_*(),
- * it cannot detect a concurrent resize or rehash, so a full iteration
- * is NOT guaranteed to terminate under adversarial or sustained
- * rehashing. Callers MUST tolerate skipped and duplicated elements and
- * SHOULD bound their loop externally.
- *
- * Returns the next element in best-effort iteration order, walking the
- * @tbl chain (including any future_tbl in flight). Caller must hold RCU.
- *
- * Pass @prev_key == NULL to obtain the first element. To iterate, set
- * @prev_key to the key of the previously returned element on each call,
- * and stop when NULL is returned.
- *
- * Best-effort semantics:
- *   - Across the tbl->future_tbl chain, an element being migrated may
- *     transiently appear in both tables and be observed twice.
- *   - Concurrent inserts may or may not be observed.
- *   - Termination of a full iteration loop is NOT guaranteed under
- *     adversarial continuous rehash; callers MUST tolerate skips and
- *     repeats and SHOULD bound their loop externally.
- *   - Behavior on tables that contain duplicate keys is undefined:
- *     duplicates may be skipped, repeated, or trap the walk in a
- *     cycle. Callers requiring duplicate-key iteration must use
- *     rhashtable_walk_*() instead.
- *   - rhltable instances are not supported and return
- *     ERR_PTR(-EOPNOTSUPP).
- *   - If prev_key was concurrently deleted and is not present in any
- *     in-flight table, returns ERR_PTR(-ENOENT).
- *
- * Returns entry of the next element, or NULL when iteration is exhausted,
- * or ERR_PTR(-ENOENT) if prev_key is not found, or
- * ERR_PTR(-EOPNOTSUPP) if @ht is an rhltable.
- */
-void *rhashtable_next_key(struct rhashtable *ht, const void *prev_key);
-
 /**
  * rhashtable_lookup - search hash table
  * @ht:		hash table

lib/rhashtable.c

@@ -730,8 +730,41 @@ static struct rhash_head *__rhashtable_next_in_table(
 
 /**
  * rhashtable_next_key - return next element after a given key
+ * @ht:		hash table
+ * @prev_key:	pointer to previous key, or NULL for the first element
  *
- * See include/linux/rhashtable.h for the full contract.
+ * WARNING: this walk is highly unstable. Unlike rhashtable_walk_*(),
+ * it cannot detect a concurrent resize or rehash, so a full iteration
+ * is NOT guaranteed to terminate under adversarial or sustained
+ * rehashing. Callers MUST tolerate skipped and duplicated elements and
+ * SHOULD bound their loop externally.
+ *
+ * Returns the next element in best-effort iteration order, walking the
+ * @tbl chain (including any future_tbl in flight). Caller must hold RCU.
+ *
+ * Pass @prev_key == NULL to obtain the first element. To iterate, set
+ * @prev_key to the key of the previously returned element on each call,
+ * and stop when NULL is returned.
+ *
+ * Best-effort semantics:
+ *   - Across the tbl->future_tbl chain, an element being migrated may
+ *     transiently appear in both tables and be observed twice.
+ *   - Concurrent inserts may or may not be observed.
+ *   - Termination of a full iteration loop is NOT guaranteed under
+ *     adversarial continuous rehash; callers MUST tolerate skips and
+ *     repeats and SHOULD bound their loop externally.
+ *   - Behavior on tables that contain duplicate keys is undefined:
+ *     duplicates may be skipped, repeated, or trap the walk in a
+ *     cycle. Callers requiring duplicate-key iteration must use
+ *     rhashtable_walk_*() instead.
+ *   - rhltable instances are not supported and return
+ *     ERR_PTR(-EOPNOTSUPP).
+ *   - If prev_key was concurrently deleted and is not present in any
+ *     in-flight table, returns ERR_PTR(-ENOENT).
+ *
+ * Returns entry of the next element, or NULL when iteration is exhausted,
+ * or ERR_PTR(-ENOENT) if prev_key is not found, or
+ * ERR_PTR(-EOPNOTSUPP) if @ht is an rhltable.
  */
 void *rhashtable_next_key(struct rhashtable *ht, const void *prev_key)
 {