git-go-patch docs: more specific editing and rebase notes

cmd/git-go-patch/README.md

@@ -10,6 +10,7 @@ For more information about why we chose this style of fork for the Microsoft Go
 Related documentation:
 
 * [set-up-repo.md](set-up-repo.md) - How to set up your repo to work with git-go-patch.
+* [microsoft/go Developer Guide](https://github.com/microsoft/go/blob/microsoft/main/eng/doc/DeveloperGuide.md) - How to use this tool as part of a microsoft/go development workflow.
 
 ## Installing
 
@@ -39,10 +40,49 @@ Sometimes you have to fix a bug in a patch file, add a new patch file, etc., and
 1. Use `git go-patch apply` to apply patches onto the submodule as a series of commits.
 1. Navigate into the submodule.
 1. Edit the commits as desired.
-   1. `git go-patch rebase` starts an interactive rebase, allowing you to do any normal Git rebase actions like reorder, squash, drop, and edit.
-   1. If it fits your workflow, use `git commit --fixup={commit}` to create fixup commits and `git go-patch rebase` to apply them.
+   * Commit-then-rebase workflow:
+     1. Make some changes in the submodule and create commits.
+     1. Use `git go-patch rebase` to start an interactive rebase.
+        1. Reorder the list to put each of your commits under the patch file that it applies to.
+        1. For each commit, choose `squash` if you want to edit the commit message or `fixup` if you don't. Use `pick` if you want to create a new patch file. (All of the built-in `rebase` options work, but these are the most common.)
+        1. The `git` command displays information about how to continue and finish the rebase.
+   * Interactive rebase `edit`:
+     * Useful if you have an exact change in mind or your commits would hit rebase conflicts.
+     1. Use `git go-patch rebase` to start an interactive rebase before you've made any changes.
+     1. Mark commits to edit with `edit` and save/close the file to continue.
+     1. When the rebase process stops at a commit, make your changes, use `git commit --amend` to edit the commit, and `git rebase --continue` to move on.
+   * Other `git rebase` features like `git commit --fixup={commit}` also work as expected.
 1. Use `git go-patch extract` to rewrite the patch files based on the changes in the submodule.
 
+### Recovering from a bad rebase
+
+It's possible to accidentally squash a commit into the wrong patch file during a rebase.
+This makes the change show up in the wrong patch file.
+To fix this, sometimes it's simplest to start from scratch and copy changes back in manually.
+However, many general `rebase` recovery methods will work.
+Here are a few strategies:
+
+#### Go back to the pre-rebase commit in the submodule
+
+You might be able to go back to the pre-rebase commit and try the `rebase` again.
+The original commit might be in your terminal history.
+Also, try `git reflog` in the submodule.
+
+If you anticipate a challenging rebase, you can also preemptively create a temporary branch in the submodule or note down the commit hash before starting the rebase.
+This way, you know for sure that you can get back to a known state if it goes wrong.
+
+#### Reallocate your changes
+
+Sometimes the original commits aren't worth recovering, only the sum total of all the changes you made.
+Then, you can create new commits to try the rebase again.
+
+1. In the submodule, `git checkout -B bad` to save your current state as the branch `bad`.
+1. In the outer repository, check out the unchanged patch files.
+1. Run `git apply -f` to apply the patch files to the submodule, changing the submodule's `HEAD`.
+1. In the submodule, `git checkout bad -- .` to copy the changes from the `bad` branch into the working directory.
+1. Split the staged changes into your desired commits.
+1. Try the rebase again.
+
 ## Fix up patch files after a submodule update
 
 Every so often, you need to update your submodule to the latest version of the upstream repo.