Removed the commit sign-off section

This is only used in go-ipfs. I have moved it to the contribution guidelines for that repository, and will open a PR on that immediately. I ran into at least one contributor who was intimidated by this section, and it is not currently mandatory for all repositories (although it potentially should be).

Done as part of #63

contribution-guidelines.md

@@ -30,94 +30,6 @@ We use a simple git branching model:
 
 Just stay current with master (rebase).
 
-### Commit messages
-
-Commit messages must start with a short subject line, followed by an optional,
-more detailed explanatory text which is separated from the summary by an empty
-line.
-
-For some of our repositories (and we'd prefer all), we check commit messages
-automatically using [GitCop](https://gitcop.com). This checks that commit
-messages are properly written.
-
-**If you are brand new to IPFS**, you'll need to run a script that adds
-`License` and `Signed-off-by` to each of your commits. These trailers mean that
-the author agrees with the [Developer Certificate of Origin (DCO)](docs/developer-certificate-of-origin)
-and with licensing the work under the [MIT license](docs/LICENSE). This is
-important for our team and our users, legally. The
-[setup_commit_msg_hook.sh](dev/tools/hooks/setup_commit_msg_hook.sh)
-script which will setup a Git commit-msg hook that will add these trailers to
-all the commit messages you write in that repository. This is not as complicated
-as it sounds: it is similar to typing `git commit --sign-off` every time you
-commit. Just download the script and run it from the root folder of whatever
-Git repository you are in (for example, go-ipfs, or ipfs).
-
-The Developer Certificate of Origin (DCO) is a document that certifies you own
-and/or have the right to contribute the work and license it appropriately. The
-DCO is used instead of a --much more annoying-- CLA. With the DCO, you retain
-copyright of your own work :). The DCO originated in the Linux community, and is
-used by other projects like Git and Docker. To learn more about the DCO see this
-[posts on elinux.org](http://elinux.org/Developer_Certificate_Of_Origin) or how
-[docker uses the DCO](https://blog.docker.com/2014/01/docker-code-contributions-require-developer-certificate-of-origin/).
-
-Gitcop checks the following:
-
-* The first line of a commit message, called the subject line should
-  not be more than 80 characters long.
-
-* The commit message should end with the following trailers:
-
-  ```
-  License: MIT
-  Signed-off-by: User Name <email@address>
-  ```
-
-  where "User Name" is the author's real (legal) name and
-  email@address is one of the author's valid email addresses.
-
-See the [documentation about amending commits](docs/amending-commits.md)
-for explanation about how you can rework commit messages.
-
-Some example commit messages:
-
-```
-parse_test: improve tests with stdin enabled arg
-
-Now also check that we get the right arguments from
-the parsing.
-
-License: MIT
-Signed-off-by: Christian Couder <chriscool@tuxfamily.org>
-```
-
-and
-
-```
-net/p2p + secio: parallelize crypto handshake
-
-We had a very nasty problem: handshakes were serial so incoming
-dials would wait for each other to finish handshaking. this was
-particularly problematic when handshakes hung-- nodes would not
-recover quickly. This led to gateways not bootstrapping peers
-fast enough.
-
-The approach taken here is to do what crypto/tls does:
-defer the handshake until Read/Write[1]. There are a number of
-reasons why this is _the right thing to do_:
-- it delays handshaking until it is known to be necessary (doing io)
-- it "accepts" before the handshake, getting the handshake out of the
-  critical path entirely.
-- it defers to the user's parallelization of conn handling. users
-  must implement this in some way already so use that, instead of
-  picking constants surely to be wrong (how many handshakes to run
-  in parallel?)
-
-[0] http://golang.org/src/crypto/tls/conn.go#L886
-
-License: MIT
-Signed-off-by: Juan Benet <juan@ipfs.io>
-```
-
 ### Code
 
 Write clean code. Universally formatted code promotes ease of writing, reading, and maintenance.