[vpm] typeMatchAnonFun improvements

need to set up symbols with approximated info for the method and its owner
before typing the method's body; when the body has been typed,
we know what its result type will be, so update info of class and method to reflect that

better detection of synthesized matches: annotate selector rather than relying on symbol info

encapsulate CASE | SYNTHETIC flags (setting and querying)
don't throw error in setError when -Ydebug
[vpm] avoid verifyerror: leave jump to tail-pos label

the following commit deals with the fall-out in basicblocks
(double closing of blocks in ignore mode)
do nothing when closing closed block in ignoremode

this came to light with the virtual pattern matcher, which
emits jumps like `matchEnd3(_test(Test.this, false))`, where _test is a tailcall
the nested jumping caused double-closing (the second time in ignore mode)
thus. when closing a closed block in ignore mode, simply do nothing

from genLoad for label-jumps:

note: when one of the args to genLoadLabelArguments is a jump to a label,
it will call back into genLoad and arrive at this case, which will then set ctx1.bb.ignore to true,
this is okay, since we're jumping unconditionally, so the loads and jumps emitted by the outer
call to genLoad (by calling genLoadLabelArguments and emitOnly) can safely be ignored,
however, as emitOnly will close the block, which reverses its instructions (when it's still open),
we better not reverse when the block has already been closed but is in ignore mode
(if it's not in ignore mode, double-closing is an error)

@dragos figured it out, all I did was write the comment and the `if`

test case to repro basic blocks crasher

the tailcall in the forward jump `matchEnd3(_test(Test.this, false))`
in the following program crashes the back-end (error below)

 @scala.annotation.tailrec final def test(meh: Boolean): Boolean = {
      <synthetic> val _$this: Test.type = Test.this;
      _test(_$this,meh){
        case <synthetic> val x1: Some[String] = new Some[String]("a");
        case3(){
          matchEnd2({
            case <synthetic> val x1: Some[String] = x1;
            case4(){
              if (x1.ne(null))
                matchEnd3(if (meh)
                  _test(Test.this, false)
                else
                  false)
              else
                case5()
            };
            case5(){
              matchEnd3(_test(Test.this, false))
            };
            matchEnd3(x){
              x
            }
          })
        };
        matchEnd2(x){
          x
        }
      }
    };

The last instruction (of basic block 11) is not a control flow instruction: CONSTANT(false)

  // methods
  def test(meh: Boolean (BOOL)): Boolean {
  locals: value meh, value _$this, value x1, value x, value x, value x1
  startBlock: 1
  blocks: [1,2,3,4,5,6,7,8,9,10,11,12,13]

  1:
    4	JUMP 2

  2:
    5	NEW REF(class Some)
    5	DUP(REF(class Some))
    5	CONSTANT("a")
    5	CALL_METHOD scala.Some.<init> (static-instance)
    5	STORE_LOCAL(value x1)
    5	SCOPE_ENTER value x1
    5	JUMP 3

  3:
    5	LOAD_LOCAL(value x1)
    7	STORE_LOCAL(value x1)
    7	SCOPE_ENTER value x1
    7	JUMP 4

  4:
    7	LOAD_LOCAL(value x1)
    7	CZJUMP (REF(class Object))NE ? 5 : 6

  5:
    8	LOAD_LOCAL(value meh)
    8	CZJUMP (BOOL)NE ? 8 : 9

  6:
    ?	JUMP 11

  7:
    7	DROP BOOL
    7	JUMP 11

  8:
    8	CONSTANT(false)
    8	STORE_LOCAL(value meh)
    8	JUMP 2

  9:
    8	CONSTANT(false)
    8	JUMP 10

  10:
    8	STORE_LOCAL(value x)
    8	JUMP 12

  11:
    9	JUMP 2
    9	STORE_LOCAL(value meh)
    9	CONSTANT(false)

  12:
    7	LOAD_LOCAL(value x)
    7	SCOPE_EXIT value x1
    7	STORE_LOCAL(value x)
    7	JUMP 13

  13:
    5	LOAD_LOCAL(value x)
    5	SCOPE_EXIT value x1
    5	RETURN(BOOL)