op: add op.Push and op.Record funcs

The funcs replace stack.Push and macro.Record, which become private.
This makes stack and macro faster to write, in particular for stacks
where you can just write the following line to save and restore the
state :

  defer op.Push(ops).Pop()

This usage requires Push to return a pointer (since Pop has a pointer
receiver), or else the code doesn't compile.

For consistancy, I tried to do the same for op.Record, but this implied
to turn all the MacroOp fields into pointers, and this caused some
panics. As a result, op.Record doesn't return a pointer.

An other side effect pointed by Larry Clapp: StackOp and MacroOp are not
re-usable any more, you have to allocate a new one for each usage, using
the described funcs above.

Signed-off-by: Thomas Bruyelle <thomas.bruyelle@gmail.com>

op/clip/clip.go

@@ -53,7 +53,7 @@ func (p Op) Add(o *op.Ops) {
 // Begin the path, storing the path data and final Op into ops.
 func (p *Path) Begin(ops *op.Ops) {
 	p.ops = ops
-	p.macro.Record(ops)
+	p.macro = op.Record(ops)
 	// Write the TypeAux opcode and a byte for marking whether the
 	// path has had its MaxY filled out. If not, the gpu will fill it
 	// before using it.

op/op.go

@@ -36,15 +36,19 @@ mutable state stack and execution flow can be controlled with macros.
 The StackOp saves the current state to the state stack and restores it later:
 
 	ops := new(op.Ops)
-	var stack op.StackOp
 	// Save the current state, in particular the transform.
-	stack.Push(ops)
+	stack := op.Push(ops)
 	// Apply a transform to subsequent operations.
 	op.TransformOp{}.Offset(...).Add(ops)
 	...
 	// Restore the previous transform.
 	stack.Pop()
 
+You can also use this one-line to save the current state and restore it at the
+end of a function :
+
+  defer op.Push(ops).Pop()
+
 The CallOp invokes another operation list:
 
 	ops := new(op.Ops)
@@ -54,8 +58,7 @@ The CallOp invokes another operation list:
 The MacroOp records a list of operations to be executed later:
 
 	ops := new(op.Ops)
-	var macro op.MacroOp
-	macro.Record(ops)
+	macro := op.Record(ops)
 	// Record operations by adding them.
 	op.InvalidateOp{}.Add(ops)
 	...
@@ -155,7 +158,13 @@ func (c CallOp) Add(o *Ops) {
 }
 
 // Push (save) the current operations state.
-func (s *StackOp) Push(o *Ops) {
+func Push(o *Ops) *StackOp {
+	var s StackOp
+	s.push(o)
+	return &s
+}
+
+func (s *StackOp) push(o *Ops) {
 	if s.active {
 		panic("unbalanced push")
 	}
@@ -221,7 +230,13 @@ func (o *Ops) pc() pc {
 }
 
 // Record a macro of operations.
-func (m *MacroOp) Record(o *Ops) {
+func Record(o *Ops) MacroOp {
+	var m MacroOp
+	m.record(o)
+	return m
+}
+
+func (m *MacroOp) record(o *Ops) {
 	if m.recording {
 		panic("already recording")
 	}