[clang-format] [NFC] update the documentation in Format.h to allow dump_format_style.py to get a little closer to being correct.

[MyDeveloperDay]

Summary

Running dump_format_style.py on the tip of the trunk causes ClangFormatStyleOptions.rst to have changes, which I think ideally it shouldn't.

Some recent commits have meant Format.h and ClangFormatStyleOptions.rst have become out of sync such that dump_format_style.py either couldn't be run or generated incorrect .rst files.

It's also important to remember to edit the IncludeStyles from Tooling.

Make a couple of changes D6833: Clang-format: Braces Indent Style Whitesmith D64695: [clang-format] Modified SortIncludes and IncludeCategories to priority for sorting #includes within the Group Category. which came from recent clang-format commits that missed this step. There are still a couple of other changes from commit D67541: [ClangFormat] Future-proof Standard option, allow floating or pinning to arbitrary lang version D68296: [clang-format] Add ability to wrap braces after multi-line control statements which also need to be looked at, but I'd like to park these first two changes first.

The authors of these original commits I've included in the reviewers, I'm happy to work on the changes, just really need to know which is the ground truth of the changes you want to keep (whats in the Format.h) or what is in the ClangFormatStyleOptions.rst

[mitchell-stellar]

LGTM.

clang/include/clang/Format/Format.h

enum BraceBreakingStyle {
     ///   }
     ///   enum X : int
     ///   {
     ///     A,
     ///     B
     ///   };
     /// \endcode
     BS_Allman,
-    /// Always break before braces and add an extra level of indentation to
-    /// braces of control statements, not to those of class, function
-    /// or other definitions.
+    /// Like ``Allman`` but always indent braces and line up code with braces.
     /// \code
-    ///   try
+    ///    try
     ///     {
-    ///       foo();
+    ///     foo();
     ///     }
     ///   catch ()
     ///     {
     ///     }
     ///   void foo() { bar(); }
     ///   class foo
-    ///   {
-    ///   };
+    ///     {
+    ///     };
     ///   if (foo())
     ///     {
     ///     }
     ///   else
     ///     {
     ///     }
     ///   enum X : int
-    ///   {
+    ///     {
     ///     A,
     ///     B
-    ///   };
+    ///     };
     /// \endcode
     BS_Whitesmiths,
-    /// Like ``Allman`` but always indent braces and line up code with braces.
+    /// Always break before braces and add an extra level of indentation to
+    /// braces of control statements, not to those of class, function
+    /// or other definitions.
     /// \code
-    ///    try
+    ///   try
     ///     {
-    ///     foo();
+    ///       foo();
     ///     }
     ///   catch ()
     ///     {
     ///     }
     ///   void foo() { bar(); }
     ///   class foo
-    ///     {
-    ///     };
+    ///   {
+    ///   };
     ///   if (foo())
     ///     {
     ///     }
     ///   else
     ///     {
     ///     }
     ///   enum X : int
-    ///     {
+    ///   {
     ///     A,
     ///     B
-    ///     };
+    ///   };
     /// \endcode
     BS_GNU,
     /// Like ``Attach``, but break before functions.
     /// \code
     ///   try {
     ///     foo();
     ///   } catch () {
     ///   }

clang/include/clang/Tooling/Inclusions/IncludeStyle.h

struct IncludeStyle {
   /// each category.
   ///
   /// If none of the regular expressions match, INT_MAX is assigned as
   /// category. The main header for a source file automatically gets category 0.
   /// so that it is generally kept at the beginning of the ``#includes``
   /// (https://llvm.org/docs/CodingStandards.html#include-style). However, you
   /// can also assign negative priorities if you have certain headers that
   /// always need to be first.
-  ///
+  /// 
+  /// There is a third and optional field ``SortPriority`` which can used while
+  /// ``IncludeBloks = IBS_Regroup`` to define the priority in which ``#includes``
+  /// should be ordered, and value of ``Priority`` defines the order of
+  /// ``#include blocks`` and also enables to group ``#includes`` of different
+  /// priority for order.``SortPriority`` is set to the value of ``Priority``
+  /// as default if it is not assigned.
+  ///
   /// To configure this in the .clang-format file, use:
   /// \code{.yaml}
   ///   IncludeCategories:
   ///     - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
   ///       Priority:        2
+  ///       SortPriority:    2
   ///     - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
   ///       Priority:        3
   ///     - Regex:           '<[[:alnum:].]+>'
   ///       Priority:        4
   ///     - Regex:           '.*'
   ///       Priority:        1
+  ///       SortPriority:    0
   /// \endcode
   std::vector<IncludeCategory> IncludeCategories;
 
   /// Specify a regular expression of suffixes that are allowed in the
   /// file-to-main-include mapping.
   ///
   /// When guessing whether a #include is the "main" include (to assign
   /// category 0, see above), use this regex of allowed suffixes to the header