Vale la pena por que el algoritmo de dijkstra es muy eficiente.
Te he hecho un programita en c++ que calcula el camino más corto entre dos celdas de un array.
Tienes obstaculos que se representan con un 1.

La función "getShortestPath" es la que lo hace todo y en el main lo que se hace es probar un ejemplo.

#include<iostream>
#include<vector>
#include<queue>
 
using namespace std;
 
class Cell{
	int x;
	int y;
public:
	int getx(){return x;}
	int gety(){return y;}
	void setx(int x){this->x=x;}
	void sety(int y){this->y=y;}
 
	bool operator==(Cell o){return x==o.x && y==o.y;}
	Cell operator=(Cell o){x=o.x; y=o.y; return *this;}
 
	Cell(int x,int y):x(x),y(y){}
	Cell():x(0),y(0){}
};
vector<Cell> getShortestPath(Cell ori, Cell dest, int array[], int width, int height);
 
 
 
int main(){
	int ejemplo[]={
		0,1,0,1,0,0,0,0,		//0: void
		0,1,0,1,0,0,0,0,		//1: obstacle
		0,1,0,1,0,0,0,0,
		0,1,0,1,0,0,0,0,
		0,1,0,1,0,0,0,0,
		0,1,0,1,0,0,0,0,
		0,0,0,1,0,0,0,0,
		0,0,0,0,0,0,0,0};
 
	vector<Cell> camino= getShortestPath(Cell(0,0),Cell(7,0),ejemplo,8,8);
	for(int i=0;i<camino.size();i++){
		cout<<"("<<camino[i].getx()<<", "<<camino[i].gety()<<")"<<endl;
	}
 
}
 
vector<Cell> getShortestPath(Cell ori, Cell dest, int array[], int width, int height){
 
	if(ori==dest) return vector<Cell>();
	unsigned int *sizes=new unsigned int[width*height];
	Cell *prev=new Cell[width*height];
	for(int i=0;i<width*height;i++){sizes[i]=-1; prev[i]=Cell(-1,-1);}
 
	sizes[ori.getx()+ori.gety()*width]=0;
	prev[ori.getx()+ori.gety()*width]=ori;
 
 
	queue<Cell> porVisitar;
	porVisitar.push(ori);
 
	while(!porVisitar.empty()){
		Cell cur=porVisitar.front();
		porVisitar.pop();
		cout<<porVisitar.size()<<endl;
		for(int i=-1;i<2;i++)
		for(int j=-1;j<2;j++)
		if(	(cur.getx()+j)>=0 && (cur.getx()+j)<width && (cur.gety()+i)>=0 && (cur.gety()+i)<height &&		//is not out of bounds
			array[(cur.getx()+j)+(cur.gety()+i)*width]==0 &&			//is not an obstable
			sizes[cur.getx()+cur.gety()*width]+1 < sizes[(cur.getx()+j)+(cur.gety()+i)*width]		//there is not a better path
		){
			sizes[(cur.getx()+j)+(cur.gety()+i)*width]=sizes[cur.getx()+cur.gety()*width]+1;
			prev[(cur.getx()+j)+(cur.gety()+i)*width]=Cell(cur.getx(),cur.gety());
			porVisitar.push(Cell(cur.getx()+j,cur.gety()+i));
		}
 
	}
 
	if(prev[dest.getx()+dest.gety()*width]==Cell(-1,-1)) return vector<Cell>();
 
	Cell pp=dest;
	vector<Cell> res(sizes[dest.getx()+dest.gety()*width]+1);
	for(int i=res.size()-1; !(pp==ori); i--){
		res[i]=pp;
		pp=prev[pp.getx()+pp.gety()*width];
	}
 
	return res;
 
}
 

Lo que se hace es considerar que:
1) Toda celda del array es un nodo.
2) Todas las celdas estan conectadas a sus vecinas.
3) Todas las aristas son bidireccionales.
4) Todas las aristas miden lo mismo: 1.

Y con esto lo que se hace es implementar dijkstra en un caso particular más sencillo.

Te pongo un pastebin para que puedas copiar y pegar:
http://pastebin.com/unRpQgK5

El algoritmo de dijkstra te podria servir. O algo adaptado.

¿Entonces tu problema es como dibujar las rectas?¿Digamos que quieres obtener los diferentes puntos de destino(porque el origen es siempre el centro)?
Pues a ver, para dibujar las rectas lo primero que tienes que hacer es decidir en cuantas partes quieres dividir el circulo(llamémosle p).
La distancia entre una recta y la siguiente en ángulo será a=(360/p)º.
Supongamos que el centro del círculo esta en (0,0).
El punto que buscamos será (r*cos(k*a), r*cos(k*a)). r es el radio y k es una constante entera.
Vayamos al código. El código que voy a poner es un pseudocódigo parecido a C(lo siento no se python).

struct Punto{
	int x;
	int y;
};
 
 
Punto origen={0, 0};
a=360/p;
for(int i=0;i<p;i++){
	Punto destino={r*cos(a*i), r*sin(a*i)};
	dibujarRecta(origen, destino);
}
 

Eso es lo que entiendo de tu pregunta a)
La pregunta b) no la llego a entender porque no se a que puntos te refieres. ¿Quieres decir todos los puntos que estan dentro de un sector?

Yo te recomendaría Qt.
Con respecto a la licencia es el LGPL. Según esta licencia los programas que hagas usando Qt pueden ser comerciales o no comerciales, libres o no libres.
Lo que no puedes hacer es comercializar una modificación de la librería.
Dependiendo del tipo de aplicación que quieras hacer también te recomendaría gtk.
Gtk es adecuado para gráficos(piensa en gimp).
Yo personalmente no aprendería windows API si no vas a aprender crackear.

De nada hombre. 
Se me había olvidado que querías programar para win32.
Tengo una mala noticia(tampoco es tan mala), los sockets no están estandarizados y por lo tanto no son multiplataforma.
El manual que te he pasado es estupendo pero tiene la pega de que se centra en entornos Unix(Posix standard).
No te desesperes. En la wiki de elhacker.net hay un tutorial que cubre los sockets Unix y windows.
http://wiki.elhacker.net/programacion/cc/articulos/introducion-a-los-sockets-en-ansi-c

Si quisieras hacer tu navegador multiplataforma tendrias que hacerlo mediante #ifdef's.
Otra alternativa sería usar otras librerías que si que son multiplataforma, como por ejemplo:

-boost -> la famosa boost! concretamente boost::asio
-NetLink Sockets C++ Library

A ver si acabo los exámenes y puedo ponerme a hacer código 

Pues mírate el manual que te he dicho. Lo bueno que tiene es que la primera parte va "al grano", sockets TCP sin opciones ni cosas que compliquen el objetivo. El resto explica todos los detalles de los socket incluso los que no son TCP.

¿Cómo llevas la programación de sockets?
Si sabes programar sockets TCP más o menos bien no te costará mucho

Es que lynx aunque parezca un navegador sincillo es muy completo.
No conozco ningún navegador tan pequeño.
Lo que te puedo decir es que para hacer un navegador sencillo sólo tienes que saber un protocolo que es http.
Y dentro de http tienes que saber hacer 2 cosas:

1) Enviar una petición
Las peticiones en http tienen esta estructura:

En resumen lo que debes hacer es crear un socket TCP, conectarlo a el servidor web que especifique el usuario y por último enviar la petición http.

2) Interpretar una respuesta.

Interpretar la respuesta del servidor será un pelín mas difícil.
Tiene esta estructura:


Si la primera linea te dice OK, entonces esta es la respuesta que queremos. Si no lo es, tenemos que enviar la petición usando otra version de http.
Ya ves que te envían cosas como la fecha(normalmente hay mas cosas). Para un navegador básico podemos ignorar todo esto y quedarnos con "Content-Length:".
A partir de eso sabes lo grande que es lo que viene a continuación.

Bien, para empezar puedes detectar con un bucle todas las tags <p> y </p> que indican que hay texto entre ellas.
Entonces imprimes por pantalla lo que hay entre todas las tags <p> y </p>.
Y con eso ya tendrias un navedor web tan simple que no puede existir algo más simple. xD

Más información en: http://es.wikipedia.org/wiki/Hypertext_Transfer_Protocol
Guia de programación sockets C: http://beej.us/guide/bgnet/output/html/singlepage/bgnet.html

Y otra cosa, si pillas el wireshark y te pones a capturar tráfico http aprenderás cómo funciona http en un periquete.

Si hombre, el código fuente está en zip.
http://lynx.isc.org/lynx2.8.7/lynx2.8.7.zip
El contenido que buscas debe de estar en el directorio WWW/Library/Implementation.

¿No es eso lo que estas buscando?

Esta es la página oficial de lynx: http://lynx.isc.org/lynx2.8.7/index.html