docs(readme): polish intro, quickstart, bottom matter, and example consistency

Top matter
- Replace three-sentence intro with a one-line tagline.
- Add a Features bullet list.
- Surface pkg.go.dev as a prominent body link.

New sections
- Quick start snippet (using NewLinked) between Import and Choosing.
- Contributing, Security, License at the bottom, each linking to
  the file that already exists in the repo.
- Maintainer callout.

Per-queue examples
- Linked Queue example: variable was named `circularQueue` (copy-paste
  from the Circular section) — renamed to `linkedQueue`.
- Priority Queue example: fix misaligned closing paren; switch
  "comparator function" to "less function" to match the code.
- Blocking Queue example: use Printf instead of Println for the elem
  output line — Println inserts a space so the old `elem: 2` comment
  was actually wrong (would print `elem:  2`).
- Normalise indentation of all code samples to tabs.

Nits
- Drop trailing whitespace on a couple of lines.
- Drop trailing space in the "## Benchmarks " heading.
- Remove the awkward "Benchmarks and Example tests can be found…" line.
- Quick-start `// 1, 2, 3, 4` comment moved above the loop and rephrased
  so it doesn't look like the output of a single Println.
- Benchmark-shape sentence now covers Priority and Delay.

No code changes.

Author: adrianbrad

README.md

@@ -17,19 +17,25 @@
 
 ---
 
-The `queue` package provides thread-safe generic implementations in Go for the following data structures: `BlockingQueue`, `PriorityQueue`, `CircularQueue`, `Linked Queue` and `DelayQueue`.
+Thread-safe, generic FIFO, priority, circular, linked, and delay queues for Go.
 
-A queue is a sequence of entities that is open at both ends where the elements are
-added (enqueued) to the tail (back) of the queue and removed (dequeued) from the head (front) of the queue.
+## Features
 
-The implementations are designed to be easy-to-use and provide a consistent API, satisfying the `Queue` interface provided by this package. .
+- Five queue flavours behind one `Queue[T comparable]` interface — swap implementations without changing call sites.
+- Generic types with no reflection; zero third-party dependencies.
+- Steady-state zero-alloc reads on every queue and zero-alloc offer/get on `Circular`, `Linked`, `Priority`, and `Delay`.
+- Blocking variants (`OfferWait`, `GetWait`, `PeekWait`) for producer/consumer workloads.
+- `Delay` queue for timers, retry scheduling, and TTL expiry.
+- 100% test coverage and race-tested in CI.
 
-Benchmarks and Example tests can be found in this package. 
+Full API reference at **[pkg.go.dev/github.com/adrianbrad/queue](https://pkg.go.dev/github.com/adrianbrad/queue)**.
 
 <!-- TOC -->
 * [queue](#queue)
+  * [Features](#features)
   * [Installation](#installation)
   * [Import](#import)
+  * [Quick start](#quick-start)
   * [Choosing a queue](#choosing-a-queue)
   * [Usage](#usage)
     * [Queue Interface](#queue-interface)
@@ -38,7 +44,10 @@ Benchmarks and Example tests can be found in this package.
     * [Circular Queue](#circular-queue)
     * [Linked Queue](#linked-queue)
     * [Delay Queue](#delay-queue)
-  * [Benchmarks](#benchmarks-)
+  * [Benchmarks](#benchmarks)
+  * [Contributing](#contributing)
+  * [Security](#security)
+  * [License](#license)
 <!-- TOC -->
 
 ## Installation
@@ -55,6 +64,32 @@ To use this package in your project, you can import it as follows:
 import "github.com/adrianbrad/queue"
 ```
 
+## Quick start
+
+```go
+package main
+
+import (
+	"fmt"
+
+	"github.com/adrianbrad/queue"
+)
+
+func main() {
+	q := queue.NewLinked([]int{1, 2, 3})
+
+	_ = q.Offer(4)
+
+	// prints 1, then 2, then 3, then 4 (one per iteration)
+	for !q.IsEmpty() {
+		v, _ := q.Get()
+		fmt.Println(v)
+	}
+}
+```
+
+Every implementation satisfies the same `Queue[T comparable]` interface — pick a different constructor (`NewBlocking`, `NewPriority`, `NewCircular`, `NewDelay`) without changing the call sites.
+
 ## Choosing a queue
 
 | Queue      | Ordering            | Capacity                                      | Blocks?                                            | Pick this when…                                                                                 |
@@ -105,7 +140,7 @@ type Queue[T comparable] interface {
 
 Blocking queue is a FIFO ordered data structure. Both blocking and non-blocking methods are implemented.
 Blocking methods wait for the queue to have available items when dequeuing, and wait for a slot to become available in case the queue is full when enqueuing.
-The non-blocking methods return an error if an element cannot be added or removed. 
+The non-blocking methods return an error if an element cannot be added or removed.
 Implemented using sync.Cond from the standard library.
 
 ```go
@@ -140,14 +175,14 @@ func main() {
 		// handle err
 	}
 
-	fmt.Println("elem: ", elem) // elem: 2
+	fmt.Printf("elem: %d\n", elem) // elem: 2
 }
 ```
 
 ### Priority Queue
 
-Priority Queue is a data structure where the order of the elements is given by a comparator function provided at construction. 
-Implemented using container/heap standard library package.
+Priority Queue is a data structure where the order of the elements is given by a less function provided at construction.
+Implemented over an internal min-heap.
 
 ```go
 package main
@@ -162,9 +197,9 @@ func main() {
 	elems := []int{2, 3, 4}
 
 	priorityQueue := queue.NewPriority(
-		elems, 
+		elems,
 		func(elem, otherElem int) bool { return elem < otherElem },
-        )
+	)
 
 	containsTwo := priorityQueue.Contains(2)
 	fmt.Println(containsTwo) // true
@@ -204,35 +239,35 @@ then the next element to be removed from the queue will be the element at index
 package main
 
 import (
-  "fmt"
+	"fmt"
 
-  "github.com/adrianbrad/queue"
+	"github.com/adrianbrad/queue"
 )
 
 func main() {
-  elems := []int{2, 3, 4}
+	elems := []int{2, 3, 4}
 
-  circularQueue := queue.NewCircular(elems, 3)
+	circularQueue := queue.NewCircular(elems, 3)
 
-  containsTwo := circularQueue.Contains(2)
-  fmt.Println(containsTwo) // true
+	containsTwo := circularQueue.Contains(2)
+	fmt.Println(containsTwo) // true
 
-  size := circularQueue.Size()
-  fmt.Println(size) // 3
+	size := circularQueue.Size()
+	fmt.Println(size) // 3
 
-  empty := circularQueue.IsEmpty()
-  fmt.Println(empty) // false
+	empty := circularQueue.IsEmpty()
+	fmt.Println(empty) // false
 
-  if err := circularQueue.Offer(1); err != nil {
-    // handle err
-  }
+	if err := circularQueue.Offer(1); err != nil {
+		// handle err
+	}
 
-  elem, err := circularQueue.Get()
-  if err != nil {
-    // handle err
-  }
+	elem, err := circularQueue.Get()
+	if err != nil {
+		// handle err
+	}
 
-  fmt.Printf("elem: %d\n", elem) // elem: 1
+	fmt.Printf("elem: %d\n", elem) // elem: 1
 }
 ```
 
@@ -247,35 +282,35 @@ without the need for traversal.
 package main
 
 import (
-  "fmt"
+	"fmt"
 
-  "github.com/adrianbrad/queue"
+	"github.com/adrianbrad/queue"
 )
 
 func main() {
-  elems := []int{2, 3, 4}
+	elems := []int{2, 3, 4}
 
-  circularQueue := queue.NewLinked(elems)
+	linkedQueue := queue.NewLinked(elems)
 
-  containsTwo := circularQueue.Contains(2)
-  fmt.Println(containsTwo) // true
+	containsTwo := linkedQueue.Contains(2)
+	fmt.Println(containsTwo) // true
 
-  size := circularQueue.Size()
-  fmt.Println(size) // 3
+	size := linkedQueue.Size()
+	fmt.Println(size) // 3
 
-  empty := circularQueue.IsEmpty()
-  fmt.Println(empty) // false
+	empty := linkedQueue.IsEmpty()
+	fmt.Println(empty) // false
 
-  if err := circularQueue.Offer(1); err != nil {
-    // handle err
-  }
+	if err := linkedQueue.Offer(1); err != nil {
+		// handle err
+	}
 
-  elem, err := circularQueue.Get()
-  if err != nil {
-    // handle err
-  }
+	elem, err := linkedQueue.Get()
+	if err != nil {
+		// handle err
+	}
 
-  fmt.Printf("elem: %d\n", elem) // elem: 2
+	fmt.Printf("elem: %d\n", elem) // elem: 2
 }
 ```
 
@@ -287,45 +322,45 @@ A `Delay` queue is a priority queue where each element becomes dequeuable at a d
 package main
 
 import (
-  "fmt"
-  "time"
+	"fmt"
+	"time"
 
-  "github.com/adrianbrad/queue"
+	"github.com/adrianbrad/queue"
 )
 
 type task struct {
-  id    int
-  runAt time.Time
+	id    int
+	runAt time.Time
 }
 
 func main() {
-  now := time.Now()
-
-  delayQueue := queue.NewDelay(
-    []task{
-      {id: 1, runAt: now.Add(20 * time.Millisecond)},
-      {id: 2, runAt: now.Add(5 * time.Millisecond)},
-    },
-    func(t task) time.Time { return t.runAt },
-  )
-
-  size := delayQueue.Size()
-  fmt.Println(size) // 2
-
-  // Non-blocking: not due yet.
-  if _, err := delayQueue.Get(); err != nil {
-    // err == queue.ErrNoElementsAvailable
-  }
-
-  // Blocking: returns as soon as the head's deadline passes.
-  next := delayQueue.GetWait()
-  fmt.Printf("next: %d\n", next.id) // next: 2
+	now := time.Now()
+
+	delayQueue := queue.NewDelay(
+		[]task{
+			{id: 1, runAt: now.Add(20 * time.Millisecond)},
+			{id: 2, runAt: now.Add(5 * time.Millisecond)},
+		},
+		func(t task) time.Time { return t.runAt },
+	)
+
+	size := delayQueue.Size()
+	fmt.Println(size) // 2
+
+	// Non-blocking: not due yet.
+	if _, err := delayQueue.Get(); err != nil {
+		// err == queue.ErrNoElementsAvailable
+	}
+
+	// Blocking: returns as soon as the head's deadline passes.
+	next := delayQueue.GetWait()
+	fmt.Printf("next: %d\n", next.id) // next: 2
 }
 ```
 
-## Benchmarks 
+## Benchmarks
 
-Run locally with `go test -bench=. -benchmem -benchtime=3s -count=3`. Reported numbers are per-operation timings and allocations; absolute values vary by hardware, but the shape (zero-alloc reads everywhere, zero-alloc offer/get for Circular and Linked) should be stable.
+Run locally with `go test -bench=. -benchmem -benchtime=3s -count=3`. Reported numbers are per-operation timings and allocations; absolute values vary by hardware, but the shape (zero-alloc reads everywhere, zero-alloc offer/get for Circular, Linked, Priority, and Delay) should be stable.
 
 ```text
 BenchmarkBlockingQueue/Peek                  3.8 ns/op       0 B/op   0 allocs/op
@@ -344,3 +379,15 @@ BenchmarkDelayQueue/Peek                     4.1 ns/op       0 B/op   0 allocs/o
 BenchmarkDelayQueue/Get_Offer               52.4 ns/op       0 B/op   0 allocs/op
 BenchmarkDelayQueue/Offer                   63.5 ns/op     315 B/op   0 allocs/op
 ```
+
+## Contributing
+
+PRs welcome — see [CONTRIBUTING.md](CONTRIBUTING.md) for the workflow, coding conventions, and the 100% coverage requirement. Ask questions by opening a GitHub issue.
+
+## Security
+
+Please report security issues privately following [SECURITY.md](SECURITY.md) rather than opening a public issue.
+
+## License
+
+MIT — see [LICENSE](LICENSE). Maintained by [@adrianbrad](https://github.com/adrianbrad).