Proportion of self-avoiding walks on a square lattice The challenge

Given a positive integer N, compute the proportion of N-step walks on a plane that don't intersect themselves.

Each step can have any of the 4 possible directions North, East, South, West.

A walk intersects itself if it visits a previously visited point. 

Examples


N=1: a single-step walk obviously doesn't intersect itself. So the result is 1.
N=2: given the first step in any direction, there are 3 possible directions that avoid intersection, and one that goes back to the origin, causing intersection. So the result is 3/4 = 0.75.
N=3: if the second step doesn't cause intersection, which happens 3/4 of the times, the third step will not cause intersection with probability again 3/4. So the result is (3/4)^2 = 0.5625.
N=4: things become more interesting because proper loops can be formed. A similar computation as above gives (3/4)^3 - 8/4^4 = 0.390625, where the second term accounts for the 8 proper loops out of the 4^4 possible paths (these are not excluded by the first term).


Additional rules


Output can be floating-point, fraction, or numerator and denominator.
If floating point, the result should be accurate up to at least the fourth decimal.
Input and output are flexible as usual. Programs or functions are allowed, in any programming language. Standard loopholes are forbidden.
Shortest code in bytes wins.


Test cases

1  -&gt; 1
2  -&gt; 0.75
3  -&gt; 0.5625
4  -&gt; 0.390625
5  -&gt; 0.27734375
6  -&gt; 0.1904296875
7  -&gt; 0.132568359375
8  -&gt; 0.09027099609375
9  -&gt; 0.0620574951171875
10 -&gt; 0.042057037353515625
11 -&gt; 0.02867984771728515625
12 -&gt; 0.0193674564361572265625
Haskell, 153 149 144 140 126 118 92 bytes
Here we represent the 2d coordinates as a single integer: We start at 0, and the directions N,E,S,W correspond to adding +n,+1,-n,-1 where n is the input (we could also use any larger number). Using this we generate all possible paths, and then just check for duplicate numbers in those paths.
Thanks @H.PWiz for -26 bytes!

g n|a&lt;-scanl(+)0&lt;$&gt;mapM(\_-&gt;[1,-1,n,-n])[1..n]=sum[1|x&lt;-a,[b|b&lt;-x,c&lt;-x,b==c]==x]/sum[1|x&lt;-a]

Try it online!
Explanation
--generate all possible paths
    a&lt;-scanl(+)0&lt;$&gt;mapM(\_-&gt;[1,-1,n,-n])[1..n]
--count the non-self intersecting paths, compute the ratio to the total
g n|a&lt;- ... =sum[1|x&lt;-a,[b|b&lt;-x,c&lt;-x,b==c]==x]/sum[1|x&lt;-a]