Address the README review: runnable script example, scope, executors

- Make the script example self-contained (it used peak from the
  notebook example) and show to_numpy() in it.
- Say that adaptive is meant for functions of a few parameters.
- Explain what the loss function is and point to the built-in
  alternatives and the custom loss tutorial.
- Say that the runners use all local cores by default, how to pass
  another executor, and link the parallelism tutorial.
- Install with plain pip install adaptive; the [notebook] extra adds
  live plotting and pandas for to_dataframe().
- Development: add the test command; the notebook git filter needs
  nbconvert and only matters for example-notebook.ipynb.
- Move the animation caption into the summary snippet, so the docs
  home page shows it too; label the conda downloads badge; fix the
  CQUAD link.
- Parallelism tutorial: drop the stale claim that Windows defaults to
  distributed.Client; loky is the default everywhere.

Author: basnijholt

README.md

@@ -7,7 +7,7 @@
 [![Python](https://img.shields.io/pypi/pyversions/adaptive.svg)](https://pypi.org/project/adaptive/)
 [![Documentation](https://img.shields.io/readthedocs/adaptive)](https://adaptive.readthedocs.io/en/latest/)
 [![Coverage](https://img.shields.io/codecov/c/github/python-adaptive/adaptive)](https://codecov.io/gh/python-adaptive/adaptive)
-[![Downloads](https://img.shields.io/conda/dn/conda-forge/adaptive.svg)](https://anaconda.org/conda-forge/adaptive)
+[![Downloads](https://img.shields.io/conda/dn/conda-forge/adaptive.svg?label=conda%20downloads)](https://anaconda.org/conda-forge/adaptive)
 [![DOI](https://img.shields.io/badge/doi-10.5281%2Fzenodo.1182437-blue.svg)](https://doi.org/10.5281/zenodo.1182437)
 [![Binder](https://mybinder.org/badge.svg)](https://mybinder.org/v2/gh/python-adaptive/adaptive/main?filepath=example-notebook.ipynb)
 
@@ -20,13 +20,14 @@ You supply a function and its bounds, and `adaptive` evaluates it at the "best"
 With a few lines of code you can run the evaluations on a computing cluster, live-plot the data as it comes in, and fine-tune the sampling algorithm.
 
 `adaptive` works best when each function evaluation takes *at least* ≈50 ms, because picking the next points has some overhead.
+It is meant for functions of a few parameters: with more dimensions, `LearnerND` quickly becomes slower and less effective.
 
 Try the example notebook [on Binder](https://mybinder.org/v2/gh/python-adaptive/adaptive/main?filepath=example-notebook.ipynb) or read the [tutorial](https://adaptive.readthedocs.io/en/latest/tutorial/tutorial/).
 
-<!-- --8<-- [end:summary] -->
-
 With the same number of points, adaptive sampling resolves features that a homogeneous grid misses:
 
+<!-- --8<-- [end:summary] -->
+
 <p align="center">
   <img src="https://raw.githubusercontent.com/python-adaptive/adaptive/main/docs/_static/readme/learner1d.gif" width="43%" alt="Learner1D: homogeneous grid versus adaptive sampling of a sharp peak">
   <img src="https://raw.githubusercontent.com/python-adaptive/adaptive/main/docs/_static/readme/learner2d.gif" width="36%" alt="Learner2D: homogeneous grid versus adaptive triangulation of a ring">
@@ -59,11 +60,17 @@ In a script, use `BlockingRunner`, which returns once the goal is reached:
 ```python
 from adaptive import BlockingRunner, Learner1D
 
+
+def peak(x, a=0.01):
+    return x + a**2 / (a**2 + x**2)
+
+
 learner = Learner1D(peak, bounds=(-1, 1))
 BlockingRunner(learner, loss_goal=0.01)
+data = learner.to_numpy()  # array with columns x, y
 ```
 
-Afterwards, `learner.to_numpy()` returns the data as a NumPy array, and `learner.to_dataframe()` as a pandas DataFrame.
+`learner.to_dataframe()` returns the same data as a pandas DataFrame (pandas comes with the `[notebook]` extra).
 
 <!-- --8<-- [start:implemented-algorithms] -->
 
@@ -74,7 +81,8 @@ A learner samples a function at the points in its parameter space that tell it t
 As it evaluates more points, it gets a better idea of where to sample next.
 
 What the "best" points are depends on your application.
-`adaptive` makes reasonable default choices, but the details of the sampling are completely customizable.
+Each learner ranks candidate points with a *loss function*.
+The default losses put more points where the function changes quickly; you can pass a built-in alternative, such as `curvature_loss_function()` or `resolution_loss_function()`, or write your own (see the [custom loss tutorial](https://adaptive.readthedocs.io/en/latest/tutorial/tutorial.custom_loss/)).
 
 The following learners are implemented:
 
@@ -100,6 +108,9 @@ In addition to the learners, `adaptive` provides primitives for running the samp
 [ipyparallel](https://ipyparallel.readthedocs.io/en/latest/), and
 [distributed](https://distributed.readthedocs.io/en/latest/).
 
+By default, both runners evaluate the function in parallel on all cores of the local machine, using loky.
+To use one of the others, pass it as `executor`, for example `Runner(learner, executor=distributed.Client())`; the [parallelism tutorial](https://adaptive.readthedocs.io/en/latest/tutorial/tutorial.parallelism/) has an example for each.
+
 <!-- --8<-- [start:rest] -->
 
 ## Installation
@@ -115,10 +126,10 @@ conda install -c conda-forge adaptive
 or from PyPI:
 
 ```bash
-pip install "adaptive[notebook]"
+pip install adaptive
 ```
 
-The `[notebook]` extra installs the dependencies for live plotting and widgets in JupyterLab and Jupyter Notebook; no Jupyter extensions are needed.
+Add the `[notebook]` extra (`pip install "adaptive[notebook]"`) for live plotting and widgets in JupyterLab and Jupyter Notebook, and for `to_dataframe()`; no Jupyter extensions are needed.
 
 ### Faster triangulation (optional)
 
@@ -143,20 +154,16 @@ pip install -e ".[notebook,test,other]"
 
 We recommend a virtual environment, for example with [uv](https://docs.astral.sh/uv/) (`uv sync --extra notebook --extra test --extra other`) or Conda.
 
-To avoid polluting the history with notebook output, set up the git filter by running
-
-```bash
-python ipynb_filter.py
-```
-
-in the repository.
-
 We use [pre-commit](https://pre-commit.com) for a consistent code style; install the hooks with
 
 ```bash
 pre-commit install
 ```
 
+Run the tests with `pytest`.
+
+If you edit `example-notebook.ipynb`, install `nbconvert` and run `python ipynb_filter.py` once, so git strips the notebook output on commit.
+
 ### Building the documentation
 
 The documentation is built with [Zensical](https://zensical.org).
@@ -190,7 +197,7 @@ The algorithms are described in more detail in a [draft paper](https://github.co
 
 We would like to give credits to the following people:
 
-- Pedro Gonnet for his implementation of [CQUAD](https://www.gnu.org/software/gsl/manual/html_node/CQUAD-doubly_002dadaptive-integration.html), "Algorithm 4" as described in "Increasing the Reliability of Adaptive Quadrature Using Explicit Interpolants", P. Gonnet, ACM Transactions on Mathematical Software, 37 (3), art. no. 26, 2010.
+- Pedro Gonnet for his implementation of [CQUAD](https://www.gnu.org/software/gsl/doc/html/integration.html#cquad-doubly-adaptive-integration), "Algorithm 4" as described in "Increasing the Reliability of Adaptive Quadrature Using Explicit Interpolants", P. Gonnet, ACM Transactions on Mathematical Software, 37 (3), art. no. 26, 2010.
 - Pauli Virtanen for his `AdaptiveTriSampling` script (no longer available online since SciPy Central went down), which served as inspiration for `adaptive.Learner2D`.
 
 <!-- --8<-- [end:rest] -->

docs/notebooks/tutorial/tutorial.parallelism.md

@@ -45,8 +45,6 @@ runner.live_plot()
 
 ## `distributed.Client`
 
-On Windows by default [`adaptive.Runner`][adaptive.Runner] uses a `distributed.Client`.
-
 ```python
 import distributed