Take away unnecessary info from the README

Author: mariascharin

README.asciidoc

@@ -5,77 +5,3 @@ This repository contains tools and tests for proving and generating documentatio
 All docs sources are maintained in AsciiDoc format.
 The primary output of building the projects kept here are artifacts (JARs) containing docs sources, code examples, and some scripts and images.
 These are processed downstream with custom tools, Asciidoctor and XSLT to produce the library of documentation available at https://neo4j.com/docs/.
-
-
-== Building
-
-Running `mvn clean install` will build and install all artifacts.
-Modules that test or generate documentation as part of their build will produce a `-docs.jar` artifact.
-The `contents` module collects these into a `neo4j-manual-contents` jar.
-Beyond this überJAR the `javadocs` and `cypher/refcard-tests` modules also produce special-purpose content JARs.
-
-The tools and tests run against Neo4j product artifacts.
-These can be downloaded from Maven Central, as ordinary dependencies.
-It is also possible to build Neo4j locally, and either deploy to a flatfile `-DaltDeploymentRepository` or install in the local Maven cache.
-The tools and tests in this repository can then be built and run against the locally produced Neo4j artifacts.
-This is the workflow for building Neo4j documentation while developing Neo4j the product.
-
-
-== Local pipeline
-
-The easiest way to build Neo4j and Neo4j documentation in step is to rely on the local Maven cache.
-Running `mvn clean install -DskipTests -T1.5C` in your local Neo4j clone followed by `mvn clean install` in your clone of this repository will achieve this.
-This is not very robust, however.
-Pretty soon Neo4j artifacts will be published to the Neo4j snapshot repository that are newer than the ones you have installed locally, and your docs build will start pulling these in instead.
-It is also very difficult to know which artifacts are actually being used.
-A module or part of a module depended on in the docs build may even be removed from the product without this surfacing and the build breaking.
-As long as you have some `SNAPSHOT` artifact for the correct version installed in the local cache this will continue to be used, until a release happens and the version is bumped.
-
-The less easy but more robust way to develop Neo4j and dependents like documentation in step, is to emulate a CI release pipeline locally.
-This could involve things like setting an explicit version on the artifacts produced, and not rely on the ever-fleeting Maven `SNAPSHOT`.
-To control the dependency chain, and to avoid interfering with other builds that may share dependencies, it may be a good idea to deploy or install artifacts in custom locations.
-The `in/` and `out/` for each build in the pipeline can be configured to provide the desired insulation.
-
-An example of achieving this would be:
-
-.Manually build `neo4j/neo4j`
-[source, sh]
-----
-$ cd $MY_NEO4J_CLONE
-$ export ALT_DEPLOYMENT_REPOSITORY=$PWD/out/neo_artifacts
-$ mvn versions:set -DnewVersion=$TARGET_VERSION
-$ mvn clean deploy -DaltDeploymentRepository=releases::default::file://$ALT_DEPLOYMENT_REPOSITORY -DskipTests -T1.5C
-$ mvn versions:revert                       # or `git reset --hard` if `versions:revert` is not thorough enough
-----
-
-
-.Manually build `neo4j/neo4j-documentation`
-[source, sh]
-----
-$ cd $MY_NEO4J_DOCUMENTATION_CLONE
-$ export MAVEN_REPO_LOCAL=$PWD/in/localRepository
-$ export ALT_DEPLOYMENT_REPOSITORY=$PWD/out/docs_artifacts
-$ ln -s $MY_NEO4J_CLONE/out/neo_artifacts $MAVEN_REPO_LOCAL
-$ mvn versions:set -DnewVersion=$TARGET_VERSION
-$ mvn clean deploy -DaltDeploymentRepository=releases::default::file://$ALT_DEPLOYMENT_REPOSITORY -Dmaven.repo.local=$MAVEN_REPO_LOCAL
-$ mvn versions:revert
-----
-
-As commandline interaction this may seem a bit heavy-handed.
-One might then consider separating _configuration_ (environment variables, symlinks, etc.) into a developer-common `devenv` and a developer-local `devenv.local` file to be sourced, and _commands_ (Maven invocations) into a `run-build` script to be executed.
-An interaction cycle might then be:
-
-.Build Neo4j and Neo4j Documentation
-[source, sh]
-----
-$ cd $MY_NEO4J_CLONE
-$ . ./devenv                                # which in turn sources ./devenv.local
-$ ./run-build
-$ cd $MY_NEO4J_DOCUMENTATION_CLONE
-$ . ./devenv
-$ ./run-build
-----
-
-This interaction might in turn easily be automated by either running one build and listen for changes to trigger others, or by scripting the steps for manual execution.
-Sprinkle some git commit hooks on top _et voilà_, you are now Snapping the CI on your own developer box.
-