What does the patch do?

 adds (EQL LAMBDAVAR LAMBDAVAR) constraints on BIND and CSET
 adds cast and test constraints to all eql lambda vars
 calculates the intersection of two lambdavar types when encountering
(IF (EQL X Y) ...) and neither X or Y is a subtype of the other
 there is now only one invocation of FINDANDPROPAGATECONSTRAINTS
 since GEN depends on IN there is no COMPUTEBLOCKOUT shortcut
anymore, a full FINDCONSTRAINTSINBLOCK is done
 for blocks whose constraints won't be recalculated after the prepass
(see LEADCOMPONENTBLOCKS) what USERESULTCONSTRAINTS would do is
done on the prepass to save time
Performance

In clbench STRINGCONCAT is 30% faster and SLURPLINES is 10% faster.
The compiler is 2% slower. There are also ghostly regressions such as
10% on deflatefile if applied to .33 but not if applied to .16.
Inheriting constraints

There is a FIXME in CONSTRAINREFTYPE that I don't quite understand:
(let* ((atype (singlevaluetype (castderivedtype node))) ; FIXME
Perhaps it means that taking the node's derived type on CASTs and CSETs
is not ideal and the current constraints should be taken into account.
Thus in the patch ADDEQLVARVARCONSTRAINT copies over constraints
for the eql vars in INHERITCONSTRAINTS. I don't know if it does any
good though, it's mostly there for comments as I haven't been able to
construct a test case where it makes a difference and clbench does not
any difference whatsoever.
Examples

A few examples where it is more clever:
;;; (TYPEP X 'FIXNUM) is derived
(defun xxx (x)
(let ((y x))
(the fixnum y)
(values (1+ x) y)))
;;; (TYPEP X 'FIXNUM) is derived
(defun xxx (x)
(let ((y nil))
(setq y x)
(the fixnum y)
(values (1+ x) y)))
;;; (TYPEP X 'FIXNUM) is derived
(defun xxx (x)
(let ((y x))
(let ((z y))
(the fixnum z)
(values (1+ x) y z))))
;;; (TYPEP X 'FIXNUM) is derived
(defun xxx (x y)
(declare (type (or fixnum null structureobject) x)
(type number y))
(when (eql x y)
(1+ x)))
;;; unreachable code
(defun xxx (x)
(let ((y x))
(when (eql x 1)
(unless (eql y 1)
(values x y)))))
